diff --git a/.editorconfig b/.editorconfig
deleted file mode 100644
index 1e5c995..0000000
--- a/.editorconfig
+++ /dev/null
@@ -1,47 +0,0 @@
-# EditorConfig is awesome: https://EditorConfig.org
-
-# top-most EditorConfig file
-root = true
-
-# Unix-style newlines with a newline ending every file
-[*]
-charset = utf-8
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-# Go files - use tabs (Go standard)
-[*.go]
-indent_style = tab
-indent_size = 4
-
-# Go mod files
-[go.{mod,sum}]
-indent_style = tab
-indent_size = 4
-
-# Makefiles - must use tabs
-[{Makefile,*.mk}]
-indent_style = tab
-indent_size = 4
-
-# YAML files
-[*.{yml,yaml}]
-indent_style = space
-indent_size = 2
-
-# JSON files
-[*.json]
-indent_style = space
-indent_size = 2
-
-# Markdown files
-[*.md]
-indent_style = space
-indent_size = 2
-trim_trailing_whitespace = false
-
-# Shell scripts
-[*.sh]
-indent_style = space
-indent_size = 2
diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml
index ca2b95d..cd989f4 100644
--- a/.gitea/workflows/ci.yml
+++ b/.gitea/workflows/ci.yml
@@ -72,7 +72,7 @@ jobs:
       - name: Build production binary
         run: |
           make build
-          echo "Binary built at: $(pwd)/bin/fj"
+          echo "Binary built at: $(pwd)/bin/fgj"
 
       - name: Run functional tests
         run: go test -v -race -tags=functional ./tests/functional/...
diff --git a/.gitea/workflows/nightly.yml b/.gitea/workflows/nightly.yml
deleted file mode 100644
index ef53290..0000000
--- a/.gitea/workflows/nightly.yml
+++ /dev/null
@@ -1,35 +0,0 @@
-name: Nightly Functional Tests
-
-on:
-  schedule:
-    # Runs every day at midnight UTC
-    - cron: '0 0 * * *'
-  workflow_dispatch:  # Allows manual trigger from the UI
-
-jobs:
-  functional:
-    runs-on: codeberg-small
-    steps:
-      - name: Checkout code
-        uses: https://github.com/actions/checkout@v4
-        with:
-          ref: main  # Always test the main branch
-
-      - name: Set up Go
-        uses: https://github.com/actions/setup-go@v5
-        with:
-          go-version: '1.21'
-          cache: true
-
-      - name: Build production binary
-        run: |
-          make build
-          echo "Binary built at: $(pwd)/bin/fj"
-
-      - name: Run functional tests
-        run: go test -v -race -tags=functional ./tests/functional/...
-        env:
-          CODEBERG_TEST_TOKEN: ${{ secrets.CODEBERG_TEST_TOKEN }}
-          CODEBERG_TEST_OWNER: ${{ vars.CODEBERG_TEST_OWNER }}
-          CODEBERG_TEST_REPO: ${{ vars.CODEBERG_TEST_REPO }}
-          CODEBERG_TEST_HOSTNAME: ${{ vars.CODEBERG_TEST_HOSTNAME || 'codeberg.org' }}
diff --git a/.gitignore b/.gitignore
index 58e31fb..f46cde4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,5 @@
 # Binaries
-fj
-bin/
+fgj
 *.exe
 *.exe~
 *.dll
@@ -29,8 +28,3 @@ Thumbs.db
 
 # Config (contains tokens)
 config.yaml
-
-# Git worktrees
-.worktrees/
-# Workspace (scratch data, cloned repos, analysis)
-.workspace/
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 170c5ec..e6edd83 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,292 +5,53 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.4.0] - 2026-05-02
-
-Audit-driven hardening pass. Three reviewers (Codex + two Claude agents
-with non-overlapping focuses) found 13 issues across cmd/ and internal/;
-this release ships fixes for all 13.
-
-### BREAKING
-
-- `--json=fields` syntax removed. The flag was a string with
-  `NoOptDefVal=" "` sentinel — `--json` alone meant "everything",
-  `--json=fields` projected. That produced `--json string[=" "]` in
-  `--help` and required a literal `=` because `--json fields` was parsed
-  as the bare flag plus a positional. **Migration**: `--json=fields` →
-  `--json-fields fields`. Bare `--json` still means "all fields as JSON".
-  `--json` and `--json-fields` are mutually exclusive; `--jq` composes
-  with either.
-
-### Added
-
-- `fj api --json` / `--json-fields` / `--jq` — projection and jq filtering
-  for raw API responses. Routes through the same `addJSONFlags` helpers
-  as the other list commands. Closes the inconsistency where `fj api`
-  was the only command returning raw JSON without these knobs.
-- `fj api --paginate` — follows RFC 5988 `Link: rel="next"` headers and
-  concatenates JSON array pages, gh-compatible. Validates same-origin
-  before forwarding the bearer token to the next URL.
-- `cmd/paginate.go` — generic `paginateGitea[T any]` helper. Applied to
-  `repo list`, `pr list`, `issue list`. Previously only `release list`
-  walked pages; the others passed `PageSize: limit` directly to the
-  gitea SDK, which silently caps PageSize at 50, so `--limit > 50` was
-  truncated without warning.
-- `CLAUDE.md` — guide for Claude Code sessions: layout, codex review
-  pattern, release process, homebrew tap update steps.
-
-### Changed
-
-- `--json` flag rebuilt as a plain `Bool`. `--json-fields` keeps
-  comma-separated projection. Both registered via `addJSONFlags` and
-  marked `MutuallyExclusive`.
-- `cmd/actions.go` — `run` and `workflow` subtrees converted from
-  package-level `var`s to factory functions (`newRunCmd`,
-  `newWorkflowCmd`, ...). `cmd/aliases.go` shrank from 142 → 17 lines
-  and now calls those same factories with a `parentLabel` parameter that
-  disambiguates the alias variant. Result: `diff` of `fj run list
-  --help` flags vs `fj actions run list --help` flags is now empty.
-  Drift between the two paths is structurally impossible.
-- `fj api` now uses `internal/api.SharedHTTPClient` (30s timeout, pooled
-  connections) instead of a zero-value `&http.Client{}` with no timeout.
-  A hung Forgejo no longer pins the CLI indefinitely.
-- `fj api` response body bounded by `io.LimitReader` at 64 MB to prevent
-  OOM-on-self.
-- `cmd/auth.go` removed redundant local `--hostname` declarations on
-  three subcommands. The persistent flag on rootCmd is now the only
-  declaration; previously local declarations shadowed it, so
-  `fj --hostname=X auth login` and `fj auth login --hostname=X` went
-  through different code paths.
-- `--token` on `auth login` emits a stderr warning when used (visible
-  in `ps auxe` and shell history). Flag not removed; just discoverable.
-- Error handling: `Hint` is now a structured field on `CLIError`.
-  JSON-error consumers get clean structure; the human renderer still
-  appends `\nHint: ...`. Dropped substring matching of `"401"`/`"403"`
-  against rendered error strings (would match issue #403); now relies
-  exclusively on typed `*api.APIError`.
-- Network errors (`no such host`, `connection refused`, `i/o timeout`)
-  return a structured `CLIError` with code `ErrNetworkError` and a hint.
-- Config dir created with mode 0700 instead of 0755.
-
-### Fixed
-
-- `--config <path>` now actually honored. Previously fed only into
-  Viper; every command that touched config went through
-  `internal/config.Load()` / `Save()` which always read the default
-  path. So `fj --config other.yaml auth login` writes to other.yaml now.
-- `fj run list --json`, `fj workflow list --json`, `fj wiki view --json`
-  now produce JSON. `cmd/aliases.go` registered `--json` as `Bool` but
-  handlers called `wantJSON()` which does `GetString("json")` — pflag
-  returned a type-error that `wantJSON` silently swallowed.
-  `cmd/wiki.go` had the inverse bug (`GetBool` against an
-  `addJSONFlags`-registered string flag). Both routed through
-  `addJSONFlags`/`wantJSON`/`outputJSON` consistently now.
-- `migrateConfigDir` opens dst with `O_TRUNC`. Previously a partially-
-  pre-existing dst file would have legacy contents overwrite a prefix
-  and leave stale tail bytes — silent YAML/token corruption. Refactored
-  close handling into `copyOneConfigFile`.
-
-### Security
-
-- `fj api` endpoint path traversal closed. `fj api '/../admin/users'`
-  previously normalized through `http.NewRequest` to
-  `https://host/admin/users` — silently sending authenticated traffic
-  to non-API paths. Endpoint is now parsed via `url.Parse`, `..`
-  segments rejected, then `JoinPath` onto the `/api/v1` base.
-  URL-encoded `%2E%2E` is also caught because Go decodes before our
-  split.
-- `fj api --paginate` validates same-origin before forwarding the
-  bearer token to a `Link: rel="next"` URL. Refuses to reattach
-  `Authorization` if the next URL's scheme isn't `https` or its host
-  doesn't match the configured one.
-- `initConfig` warns on stderr if the resolved config file is world or
-  group readable (`mode & 0o077 != 0`).
-
-## [0.3.0c] - 2026-03-21
-
-### Added
-
-#### Label Management
-- `fj label list` - List repository labels
-- `fj label create` - Create a label with color and description
-- `fj label edit` - Edit label name, color, or description
-- `fj label delete` - Delete a label
-
-#### Milestone Management
-- `fj milestone list` - List milestones with state filtering
-- `fj milestone view` - View milestone details
-- `fj milestone create` - Create a milestone with description and due date
-- `fj milestone edit` - Edit milestone title, description, due date, or state
-- `fj milestone delete` - Delete a milestone
-
-#### Wiki Management
-- `fj wiki list` - List wiki pages
-- `fj wiki view` - View wiki page content
-- `fj wiki create` - Create a wiki page from flag or file
-- `fj wiki edit` - Edit a wiki page
-- `fj wiki delete` - Delete a wiki page
-
-#### Issue Dependencies
-- `fj issue edit --add-dependency <number>` - Add issue dependency
-- `fj issue edit --remove-dependency <number>` - Remove issue dependency
-
-## [0.3.0b] - 2026-03-21
-
-### Added
-
-#### Repository Management
-- `fj repo edit` - Edit repository settings (visibility, description, homepage, default branch)
-
-### Fixed
-- `fj repo create --public` flag was defined but never read; now properly wired up
-
-## [0.3.0a] - 2026-03-21
-
-### Added
-
-#### Raw API Access
-- `fj api <endpoint>` - Make authenticated REST API requests to any Forgejo/Gitea endpoint
-  - HTTP method selection (`--method`/`-X`), auto-switches to POST when fields are provided
-  - JSON field assembly (`--field`/`-f`) with type inference (bool, int, float, null, string)
-  - Raw string fields (`--raw-field`/`-F`)
-  - Request body from file or stdin (`--input`)
-  - Custom headers (`--header`/`-H`)
-  - Path interpolation (`{owner}`, `{repo}`) from git context
-  - Response header display (`--include`/`-i`)
-
-#### Pull Request Management
-- `fj pr diff <number>` - View the diff for a pull request
-  - Colorized output (`--color auto/always/never`)
-  - Changed file names only (`--name-only`)
-  - Diffstat summary (`--stat`)
-- `fj pr comment <number>` - Add a comment to a pull request
-  - Body from flag (`--body`/`-b`) or file (`--body-file`, `-` for stdin)
-  - JSON output (`--json`)
-- `fj pr review <number>` - Submit a review on a pull request
-  - Approve (`--approve`/`-a`), request changes (`--request-changes`/`-r`), or comment (`--comment`/`-c`)
-  - Body from flag or file
-  - JSON output (`--json`)
-
-#### Agentic / Machine-Readable Output
-- `--json-errors` global flag for structured JSON error output on stderr
-  - Error codes: `auth_required`, `not_found`, `api_error`, `invalid_input`, `git_detection_failed`, `network_error`
-  - HTTP status code and detail included when available
-  - Automatic mapping of API errors (401/403 → `auth_required`, 404 → `not_found`)
-
-## [0.3.0] - 2026-03-13
-
-### Added
-
-#### Forgejo Actions
-- `fj actions run watch <run-id>` - Poll a run until completion
-- `fj actions run rerun <run-id>` - Trigger a rerun of a workflow run
-- `fj actions run cancel <run-id>` - Cancel an in-progress workflow run
-- `fj actions workflow enable <workflow>` - Enable a workflow
-- `fj actions workflow disable <workflow>` - Disable a workflow
-
-#### Repository Management
-- `fj repo create <name>` - Create a new repository with full option set: `--private`/`--public`, `--description`, `--add-readme`, `--gitignore`, `--license`, `--homepage`, `--clone`, `--team`
-
-#### Issue Management
-- `fj issue create -l <label>` - Assign labels when creating an issue
-- `fj issue edit --add-label` / `--remove-label` - Add or remove labels on existing issues
-- `fj issue close -c <comment>` - Close an issue with an optional comment
-
-#### Workflow Management
-- `fj actions workflow list/view/run` - List, view, and trigger workflows
-
-#### Auth Helpers
-- `fj auth token` - Print the stored token for the current host
-- `fj auth logout` - Remove authentication for a host
-
-#### Shell Completions and Man Pages
-- `fj completion [bash|zsh|fish|powershell]` - Generate shell completion scripts
-- `fj manpages --dir <path>` - Generate man pages for all commands
-
-#### JSON Output
-- `--json` flag for all list and view commands: PRs, issues, releases, workflow runs, workflows
-
-### Fixed
-- Respect `$XDG_CONFIG_HOME` for config file location (was always using `~/.config`)
-
-## [0.2.0] - 2026-01-09
-
-### Added
-
-#### Release Management
-- `fj release list` - List releases for a repository
-- `fj release view` - View details of a specific release (supports "latest" keyword)
-- `fj release create` - Create new releases with optional asset uploads
-- `fj release upload` - Upload assets to existing releases with optional clobber support
-- `fj release delete` - Delete releases (preserves Git tags)
-
-#### Issue Management
-- `fj issue edit` - Edit existing issues with support for updating title, body, and labels
-
-#### Pull Request Management
-- `fj pr create --assignee` - Assign users when creating pull requests
-
-#### Repository Detection
-- Automatic hostname detection from git remote URLs
-- Improved multi-instance support with auto-detection from git context
-
-### Improved
-- Enhanced documentation with AUR and Homebrew installation instructions
-- Added functional tests for release management and issue editing
-- Added Makefile `install` target for easier local installation
-- Added `.editorconfig` for consistent code formatting
-
-### Development
-- CI: Added nightly builds for continuous testing
-- Expanded functional test coverage for new features
-
 ## [0.1.0] - 2025-12-16
 
 ### Added
 
 #### Core Features
-- Initial release of fj - Forgejo CLI tool
+- Initial release of fgj - Forgejo CLI tool
 - Multi-instance support for any Forgejo/Gitea instance
 - Automatic repository detection from git context (optional `-R` flag)
 - Secure authentication with personal access tokens
-- Configuration management via `~/.config/fj/config.yaml`
+- Configuration management via `~/.config/fgj/config.yaml`
 
 #### Pull Request Management
-- `fj pr list` - List pull requests with filtering by state
-- `fj pr view` - View detailed pull request information
-- `fj pr create` - Create new pull requests
-- `fj pr merge` - Merge pull requests with configurable merge methods
+- `fgj pr list` - List pull requests with filtering by state
+- `fgj pr view` - View detailed pull request information
+- `fgj pr create` - Create new pull requests
+- `fgj pr merge` - Merge pull requests with configurable merge methods
 
 #### Issue Management
-- `fj issue list` - List issues with state filtering
-- `fj issue view` - View detailed issue information
-- `fj issue create` - Create new issues
-- `fj issue comment` - Add comments to issues
-- `fj issue close` - Close issues
+- `fgj issue list` - List issues with state filtering
+- `fgj issue view` - View detailed issue information
+- `fgj issue create` - Create new issues
+- `fgj issue comment` - Add comments to issues
+- `fgj issue close` - Close issues
 
 #### Repository Operations
-- `fj repo view` - View repository details
-- `fj repo list` - List user repositories
-- `fj repo clone` - Clone repositories with protocol selection (HTTPS/SSH)
-- `fj repo fork` - Fork repositories
+- `fgj repo view` - View repository details
+- `fgj repo list` - List user repositories
+- `fgj repo clone` - Clone repositories with protocol selection (HTTPS/SSH)
+- `fgj repo fork` - Fork repositories
 
 #### Forgejo Actions Support
-- `fj actions run list` - List workflow runs with status and metadata
-- `fj actions run view` - View detailed run information, jobs, and logs
+- `fgj actions run list` - List workflow runs with status and metadata
+- `fgj actions run view` - View detailed run information, jobs, and logs
   - Support for `--verbose`, `--log`, `--log-failed`, and `--job` flags
-- `fj actions secret list` - List repository secrets
-- `fj actions secret create` - Create repository secrets
-- `fj actions secret delete` - Delete repository secrets
-- `fj actions variable list` - List repository variables
-- `fj actions variable get` - Get variable values
-- `fj actions variable create` - Create repository variables
-- `fj actions variable update` - Update repository variables
-- `fj actions variable delete` - Delete repository variables
+- `fgj actions secret list` - List repository secrets
+- `fgj actions secret create` - Create repository secrets
+- `fgj actions secret delete` - Delete repository secrets
+- `fgj actions variable list` - List repository variables
+- `fgj actions variable get` - Get variable values
+- `fgj actions variable create` - Create repository variables
+- `fgj actions variable update` - Update repository variables
+- `fgj actions variable delete` - Delete repository variables
 
 #### Authentication
-- `fj auth login` - Interactive authentication with Forgejo instances
-- `fj auth status` - Check authentication status
-- Environment variable support (`FJ_HOST`, `FJ_TOKEN`)
+- `fgj auth login` - Interactive authentication with Forgejo instances
+- `fgj auth status` - Check authentication status
+- Environment variable support (`FGJ_HOST`, `FGJ_TOKEN`)
 
 #### Development
 - Comprehensive unit test suite
@@ -304,9 +65,4 @@ this release ships fixes for all 13.
 - Cobra framework for CLI structure
 - Viper for configuration management
 
-[0.3.0c]: https://forgejo.zerova.net/public/fj/releases/tag/v0.3.0c
-[0.3.0b]: https://forgejo.zerova.net/public/fj/releases/tag/v0.3.0b
-[0.3.0a]: https://forgejo.zerova.net/public/fj/releases/tag/v0.3.0a
-[0.3.0]: https://codeberg.org/romaintb/fj/releases/tag/v0.3.0
-[0.2.0]: https://codeberg.org/romaintb/fj/releases/tag/v0.2.0
-[0.1.0]: https://codeberg.org/romaintb/fj/releases/tag/v0.1.0
+[0.1.0]: https://codeberg.org/romaintb/fgj/releases/tag/v0.1.0
diff --git a/CLAUDE.md b/CLAUDE.md
deleted file mode 100644
index dfece55..0000000
--- a/CLAUDE.md
+++ /dev/null
@@ -1,166 +0,0 @@
-# fj — guide for Claude Code sessions
-
-`fj` is a personal Forgejo/Gitea CLI tool, modeled on GitHub's `gh`. It targets `forgejo.zerova.net` (and Codeberg). The user (sid) owns it; the canonical repo is `public/fj` on forgejo.zerova.net (mirrored from there to nowhere else).
-
-This file is read first by Claude Code when working in `~/repos/fj`. Goal: get a session productive quickly without re-deriving the dev workflow each time.
-
-## Layout
-
-```
-~/repos/fj/
-├── cmd/                 cobra command definitions, one file per subject area
-│   ├── root.go          rootCmd, --config plumbing, OnInitialize
-│   ├── auth.go          login/status/logout/token (uses persistent --hostname)
-│   ├── api.go           raw API access; --json/--json-fields/--jq/--paginate
-│   ├── json.go          shared JSON output helpers (addJSONFlags/wantJSON/outputJSON)
-│   ├── paginate.go      generic paginateGitea[T] helper for list commands
-│   ├── errors.go        CLIError with structured Hint field
-│   ├── actions.go       Forgejo Actions; runs/workflows via factory functions
-│   ├── aliases.go       top-level `fj run` / `fj workflow` aliases — calls actions.go factories
-│   ├── repo.go pr.go issue.go release.go wiki.go label.go milestone.go
-│   └── ...
-├── internal/
-│   ├── api/client.go    SharedHTTPClient (30s timeout); GetJSON/DoJSON/DownloadFile
-│   ├── config/config.go YAML config; honors --config via SetExplicitConfigPath
-│   ├── git/             repo + host detection from `git remote`
-│   ├── iostreams/       wrapped stdin/stdout/stderr + spinner + pager + colors
-│   └── text/            formatting helpers
-├── main.go              thin entrypoint; ContextualError + JSON-error rendering
-├── Makefile             build / lint / test (no release automation)
-├── CHANGELOG.md         Keep-a-Changelog format
-└── README.md
-```
-
-## Build, install, test
-
-```bash
-go build ./...               # quick build check
-go test ./...                # unit tests
-go install .                 # build + install to ~/go/bin/fj (the binary that's on PATH)
-make lint                    # golangci-lint, if you have it
-```
-
-After any change in cmd/ or internal/, run `go install .` and the global `fj` reflects it immediately. There's no daemon/restart.
-
-## Auth
-
-The user is authenticated as `sid` on `forgejo.zerova.net`. Token lives in `~/.config/fj/config.yaml` (mode 0600). For HTTPS git pushes from this host, the token can be injected via `git -c "http.extraHeader=Authorization: token <T>" push` — the local SSH key (`sid@debian` on forgejo) is also registered, so `git@forgejo.zerova.net:public/fj.git` works directly.
-
-## Code review pattern (use this for non-trivial changes)
-
-For audits or significant refactors, run **three reviewers in parallel** with non-overlapping focuses (we did this in the v0.4.0 cycle and it found bugs none would have caught alone):
-
-- **Codex** — read-only sandbox, peer-AI cross-check
-  ```bash
-  codex exec --skip-git-repo-check --sandbox read-only \
-    -m gpt-5.4-mini --config model_reasoning_effort="medium" "<prompt>" 2>/dev/null
-  ```
-  For follow-up rounds resume the same session: `echo "<prompt>" | codex exec --skip-git-repo-check resume --last 2>/dev/null`. Codex remembers prior critique.
-
-- **Claude general-purpose agent A** — architecture / UX / code-quality
-- **Claude general-purpose agent B** — security / correctness / error handling
-
-Tell each reviewer what the **siblings** are covering so they don't duplicate. Cap reports at ~600 words. Consolidate findings by severity (HIGH / MEDIUM / LOW) before presenting to the user.
-
-## Release process
-
-We use semver. **Pre-1.0**: breaking change → minor bump (e.g. v0.3.x → v0.4.0).
-
-1. **Bump version**
-   ```go
-   // cmd/root.go
-   Version: "0.4.0",
-   ```
-
-2. **Update CHANGELOG.md** — prepend a new section. Format:
-   ```markdown
-   ## [0.4.0] - YYYY-MM-DD
-
-   ### BREAKING
-   - <thing that broke>
-
-   ### Added
-   - ...
-   ### Changed
-   - ...
-   ### Fixed
-   - ...
-   ### Security
-   - ...
-   ```
-
-3. **Commit** the version+changelog bump as a single commit:
-   ```bash
-   git commit -m "chore: bump version to 0.4.0"
-   ```
-
-4. **Tag** the commit:
-   ```bash
-   git tag -a v0.4.0 -m "Release v0.4.0: <one-line summary>"
-   ```
-
-5. **Push** commits and tag:
-   ```bash
-   git push origin main
-   git push origin v0.4.0
-   ```
-
-6. **Create the Forgejo release page** via fj itself:
-   ```bash
-   fj release create v0.4.0 \
-     --title "v0.4.0: <summary>" \
-     --notes "$(awk '/^## \[0.4.0\]/{flag=1;next} /^## /{flag=0} flag' CHANGELOG.md)"
-   ```
-   (The awk one-liner extracts the just-added CHANGELOG section as release notes.)
-
-7. **Update the homebrew tap** — see the next section.
-
-## Updating the homebrew tap (`public/homebrew-sid`)
-
-The tap lives at `~/repos/homebrew-sid` (or `git@forgejo.zerova.net:public/homebrew-sid.git`). The `Formula/fj.rb` formula references the source by `tag:` + `revision:` (SHA), so a release bump touches three lines:
-
-```ruby
-url "ssh://git@forgejo.zerova.net/public/fj.git",
-    tag:      "v0.4.0",                                      # was v0.3.2
-    revision: "<SHA of v0.4.0 tag>"                          # update
-
-test do
-  assert_match "0.4.0", shell_output("#{bin}/fj --version")  # update
-end
-```
-
-To get the SHA:
-```bash
-git -C ~/repos/fj rev-parse v0.4.0
-```
-
-Then in `~/repos/homebrew-sid`:
-```bash
-# edit Formula/fj.rb (the three lines above)
-git commit -am "fj: bump to v0.4.0"
-git push origin main
-```
-
-After push, users can `brew update && brew upgrade fj` to pick up the new version.
-
-## Common footguns
-
-- **`fj` reads the current dir's `git origin`** to detect the host. In a directory whose origin points at github.com (e.g. /opt/stacks/claude-code-proxy/build), bare `fj api ...` errors with "no configuration found for host github.com". Pass `--hostname forgejo.zerova.net` explicitly, or `cd` somewhere else.
-- **`--json=fields` was removed in v0.4.0** in favor of `--json-fields fields` (or `--json-fields=fields`). The old `=fields` form was a `NoOptDefVal=" "` sentinel hack. `--json` is now a plain Bool meaning "as JSON".
-- **`--config` was silently ignored before v0.4.0.** Old fj versions read --config into Viper but `internal/config.Load()` always read the default path. Fixed; `fj --config other.yaml auth login` now writes to other.yaml.
-- **The `actions` and `run`/`workflow` command trees share factory functions** in `cmd/actions.go` (`newRunCmd`, `newWorkflowCmd`). Don't add flags directly to `runListCmd` style globals — they don't exist anymore. Edit the factory and both `fj actions run list` and `fj run list` get the change.
-
-## Useful commands
-
-```bash
-# Live test against forgejo (using the new flags)
-fj --hostname forgejo.zerova.net api repos/public/fj --json-fields full_name,description
-
-# Walk paginated endpoints
-fj --hostname forgejo.zerova.net api 'repos/public/fj/commits?limit=10' --paginate --jq '.[].sha[0:8]'
-
-# Confirm both command trees stay in sync after edits
-diff <(fj run list --help | grep -E "^  -|^      --" | sort) \
-     <(fj actions run list --help | grep -E "^  -|^      --" | sort)
-# Empty diff = trees agree. Any output = factory drift.
-```
diff --git a/Makefile b/Makefile
index 54158dd..57e8eda 100644
--- a/Makefile
+++ b/Makefile
@@ -1,9 +1,8 @@
-.PHONY: help build run test clean lint lint-fix install
+.PHONY: help build run test clean lint lint-fix
 
 help:
 	@echo "Available commands:"
 	@echo "  make build      - Build the application"
-	@echo "  make install    - Install the binary to /usr/bin"
 	@echo "  make run        - Run the application"
 	@echo "  make test       - Run tests"
 	@echo "  make lint       - Run golangci-lint"
@@ -11,10 +10,7 @@ help:
 	@echo "  make clean      - Clean build artifacts"
 
 build:
-	go build -o bin/fj .
-
-install: build
-	install -Dm755 bin/fj /usr/bin/fj
+	go build -o bin/fgj .
 
 run:
 	go run .
diff --git a/README.md b/README.md
index da5bac5..2d71dc8 100644
--- a/README.md
+++ b/README.md
@@ -1,72 +1,55 @@
-# fj - Forgejo/Gitea CLI Tool
+# fgj - Forgejo CLI Tool
 
 [![Go Version](https://img.shields.io/badge/Go-1.23+-00ADD8?style=flat-square&logo=go)](https://golang.org)
+[![CI Status](https://codeberg.org/romaintb/fgj/actions/workflows/ci.yml/badge.svg)](https://codeberg.org/romaintb/fgj/actions)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](LICENSE)
 
-`fj` is a command-line tool for working with Forgejo and Gitea instances. It brings pull requests, issues, and other forge concepts to the terminal, similar to what `gh` does for GitHub. This fork adds agentic dev features — raw API access, PR review workflows, structured error output, and machine-readable I/O for AI coding agents.
-
-> Forked from [codeberg.org/romaintb/fj](https://codeberg.org/romaintb/fj) and hosted at [forgejo.zerova.net/public/fj](https://forgejo.zerova.net/public/fj).
+`fgj` is a command-line tool for working with Forgejo instances (including Codeberg.org). It brings pull requests, issues, and other Forgejo concepts to the terminal, similar to what `gh` does for GitHub.
 
 ## Features
 
-- Multi-instance support (works with any Forgejo or Gitea instance)
-- Pull request management (create, list, view, merge, diff, comment, review)
-- Issue tracking (create, list, view, comment, close, labels)
-- Repository operations (view, list, create, edit, clone, fork)
-- Label management (list, create, edit, delete)
-- Milestone management (list, view, create, edit, delete)
-- Wiki page management (list, view, create, edit, delete)
-- Issue dependencies (`--add-dependency`, `--remove-dependency`)
-- Forgejo Actions (workflow runs, watch/rerun/cancel, enable/disable, secrets, variables)
-- Releases (create, upload, delete)
-- Raw API access (`fj api`) for arbitrary REST calls
-- Shell completions (bash, zsh, fish, PowerShell) and man pages
-- JSON output (`--json`) for all list/view commands
-- Structured JSON error output (`--json-errors`) for machine consumption
-- Automatic repository and hostname detection from git context
+- Multi-instance support (works with any Forgejo instance)
+- Pull request management (create, list, view, merge)
+- Issue tracking (create, list, view, comment, close)
+- Repository operations (view, list, clone, fork)
+- Forgejo Actions (workflow runs, secrets, variables)
+- Automatic repository detection from git context
 - Secure authentication with personal access tokens
-- XDG Base Directory compliant config location
 - AI coding agent friendly
 
 ## Installation
 
-### macOS (Homebrew)
+### From Source
 
 ```bash
-brew tap public/sid git@forgejo.zerova.net:public/homebrew-sid.git
-brew install fj
+git clone https://codeberg.org/romaintb/fgj.git
+cd fgj
+go build -o fgj
+sudo mv fgj /usr/local/bin/
 ```
 
 ### Using Go Install
 
 ```bash
-go install forgejo.zerova.net/public/fj@latest
-```
-
-### From Source
-
-```bash
-git clone https://forgejo.zerova.net/public/fj.git
-cd fj
-go build -o fj .
+go install codeberg.org/romaintb/fgj@latest
 ```
 
 ## Quick Start
 
 ### 1. Authenticate
 
-First, authenticate with your Forgejo or Gitea instance:
+First, authenticate with your Forgejo instance:
 
 ```bash
-fj auth login
+fgj auth login
 ```
 
 You'll be prompted for:
-- Instance hostname (default: codeberg.org)
+- Forgejo instance hostname (default: codeberg.org)
 - Personal access token
 
 To create a personal access token:
-1. Go to your instance (e.g., https://forgejo.zerova.net)
+1. Go to your Forgejo instance (e.g., https://codeberg.org)
 2. Navigate to Settings > Applications > Generate New Token
 3. Give it appropriate permissions (repo, issue, etc.)
 4. Copy the token and paste it when prompted
@@ -74,510 +57,237 @@ To create a personal access token:
 ### 2. Check Authentication Status
 
 ```bash
-fj auth status
-```
-
-### Auth Helpers
-
-```bash
-# Print the stored token for the current host
-fj auth token
-
-# Remove authentication for a host
-fj auth logout
+fgj auth status
 ```
 
 ## Usage
 
 ### Repository Detection
 
-`fj` automatically detects the repository from your git context, similar to `gh`:
+`fgj` automatically detects the repository from your git context, similar to `gh`:
 
 ```bash
 # When inside a git repository, no -R flag needed!
 cd /path/to/your/repo
-fj pr list              # Automatically uses current repo
-fj issue list           # Automatically uses current repo
-fj pr view 123          # Automatically uses current repo
+fgj pr list              # Automatically uses current repo
+fgj issue list           # Automatically uses current repo
+fgj pr view 123          # Automatically uses current repo
 
 # Or explicitly specify a repository with -R
-fj pr list -R owner/repo
+fgj pr list -R owner/repo
 ```
 
-The tool reads `.git/config` to find the origin remote and extract both the owner/repo information and the instance hostname. If you're not in a git repository, you'll need to use the `-R` flag.
+The tool reads `.git/config` to find the origin remote and extract the owner/repo information. If you're not in a git repository, you'll need to use the `-R` flag.
 
 ### Pull Requests
 
 ```bash
-# List pull requests (auto-detects repo and hostname from git)
-fj pr list
+# List pull requests (auto-detects repo from git)
+fgj pr list
 
 # Or specify explicitly
-fj pr list -R owner/repo
+fgj pr list -R owner/repo
 
 # Filter by state
-fj pr list --state closed
+fgj pr list --state closed
 
 # View a specific pull request
-fj pr view 123
+fgj pr view 123
 
 # Create a pull request
-fj pr create -t "PR Title" -b "PR Description" -H feature-branch -B main
+fgj pr create -t "PR Title" -b "PR Description" -H feature-branch -B main
 
 # Merge a pull request
-fj pr merge 123 --merge-method squash
-
-# View PR diff
-fj pr diff 123
-
-# View diff with color
-fj pr diff 123 --color always
-
-# Show only changed file names
-fj pr diff 123 --name-only
-
-# Show diffstat summary
-fj pr diff 123 --stat
-
-# Comment on a pull request
-fj pr comment 123 -b "Looks good, minor nit on line 42"
-
-# Comment from a file
-fj pr comment 123 --body-file review-notes.md
-
-# Approve a pull request
-fj pr review 123 --approve -b "LGTM"
-
-# Request changes
-fj pr review 123 --request-changes -b "Please fix the error handling"
-
-# Submit a review comment (neither approve nor request changes)
-fj pr review 123 --comment -b "Some observations"
+fgj pr merge 123 --merge-method squash
 ```
 
 ### Issues
 
 ```bash
-# List issues (auto-detects repo and hostname from git)
-fj issue list
+# List issues (auto-detects repo from git)
+fgj issue list
 
 # Or specify explicitly
-fj issue list -R owner/repo
+fgj issue list -R owner/repo
 
 # Filter by state
-fj issue list --state all
+fgj issue list --state all
 
 # View an issue
-fj issue view 456
+fgj issue view 456
 
 # Create an issue
-fj issue create -t "Issue Title" -b "Issue Description"
-
-# Create an issue with labels
-fj issue create -t "Issue Title" -b "Issue Description" -l bug -l enhancement
+fgj issue create -t "Issue Title" -b "Issue Description"
 
 # Comment on an issue
-fj issue comment 456 -b "My comment"
+fgj issue comment 456 -b "My comment"
 
 # Close an issue
-fj issue close 456
-
-# Close an issue with a comment
-fj issue close 456 -c "Fixed in v2.0"
-
-# Edit an issue (title, body, state, labels)
-fj issue edit 456 -t "New Title"
-fj issue edit 456 --add-label priority --remove-label bug
-
-# Manage issue dependencies
-fj issue edit 456 --add-dependency 123
-fj issue edit 456 --remove-dependency 123
-```
-
-### Labels
-
-```bash
-# List labels
-fj label list
-
-# Create a label
-fj label create bug --color ff0000 -d "Something isn't working"
-
-# Edit a label
-fj label edit bug --name bugfix --color ee0000
-
-# Delete a label
-fj label delete bug
-```
-
-### Milestones
-
-```bash
-# List milestones
-fj milestone list
-fj milestone list --state all
-
-# View a milestone
-fj milestone view "v1.0"
-
-# Create a milestone with due date
-fj milestone create "v2.0" -d "Next major release" --due 2026-06-01
-
-# Edit a milestone
-fj milestone edit "v2.0" --title "v2.0-rc1" --state closed
-
-# Delete a milestone
-fj milestone delete "v2.0"
-```
-
-### Wiki
-
-```bash
-# List wiki pages
-fj wiki list
-
-# View a wiki page
-fj wiki view "Home"
-
-# Create a wiki page
-fj wiki create "Setup Guide" -b "# Setup\n\nFollow these steps..."
-
-# Create from file
-fj wiki create "API Docs" --body-file docs/api.md
-
-# Edit a wiki page
-fj wiki edit "Home" -b "Updated content"
-
-# Delete a wiki page
-fj wiki delete "Old Page"
+fgj issue close 456
 ```
 
 ### Repositories
 
 ```bash
 # View repository details
-fj repo view owner/repo
+fgj repo view owner/repo
 
 # List your repositories
-fj repo list
-
-# Create a repository
-fj repo create my-repo
-fj repo create my-repo -d "My project" --private --add-readme -g Go -l MIT
+fgj repo list
 
 # Clone a repository
-fj repo clone owner/repo
+fgj repo clone owner/repo
 
 # Clone via SSH
-fj repo clone owner/repo -p ssh
+fgj repo clone owner/repo -p ssh
 
 # Fork a repository
-fj repo fork owner/repo
-
-# Edit repository settings
-fj repo edit owner/repo --public
-fj repo edit owner/repo --private
-fj repo edit owner/repo -d "New description" --homepage https://example.com
-fj repo edit --default-branch develop
-fj repo edit owner/repo --name new-name
-
-# Rename a repository (shorthand)
-fj repo rename new-name
-fj repo rename new-name -R owner/old-name
-```
-
-### Releases
-
-```bash
-# List releases
-fj release list
-
-# View a release (or use "latest")
-fj release view v1.2.3
-
-# Create a release with notes and optional assets
-fj release create v1.2.3 -t "v1.2.3" -n "Release notes" ./dist/app.tar.gz
-
-# Upload assets to an existing release
-fj release upload v1.2.3 ./dist/app.tar.gz --clobber
-
-# Delete a release (keeps the Git tag)
-fj release delete v1.2.3
+fgj repo fork owner/repo
 ```
 
 ### Forgejo Actions
 
 ```bash
-# List workflows
-fj actions workflow list
-
-# View a workflow
-fj actions workflow view ci.yml
-
-# Run a workflow (trigger workflow_dispatch)
-fj actions workflow run deploy.yml
-
-# Run a workflow with inputs
-fj actions workflow run deploy.yml -f environment=production -f version=1.2.3
-
-# Run a workflow on a specific branch
-fj actions workflow run deploy.yml -r feature-branch
-
-# Enable or disable a workflow
-fj actions workflow enable ci.yml
-fj actions workflow disable ci.yml
-
 # List workflow runs
-fj actions run list
+fgj actions run list
 
 # View a specific run
-fj actions run view 123
+fgj actions run view 123
 
 # View run with job details
-fj actions run view 123 --verbose
+fgj actions run view 123 --verbose
 
 # View run logs
-fj actions run view 123 --log
+fgj actions run view 123 --log
 
 # View specific job logs
-fj actions run view 123 --job 456 --log
-
-# Watch a run until completion
-fj actions run watch 123
-
-# Rerun a workflow run
-fj actions run rerun 123
-
-# Cancel a running workflow
-fj actions run cancel 123
+fgj actions run view 123 --job 456 --log
 
 # List secrets
-fj actions secret list
+fgj actions secret list
 
 # Create a secret
-fj actions secret create MY_SECRET
+fgj actions secret create MY_SECRET
 
 # Delete a secret
-fj actions secret delete MY_SECRET
+fgj actions secret delete MY_SECRET
 
 # List variables
-fj actions variable list
+fgj actions variable list
 
 # Get a variable
-fj actions variable get MY_VAR
+fgj actions variable get MY_VAR
 
 # Create a variable
-fj actions variable create MY_VAR "value"
+fgj actions variable create MY_VAR "value"
 
 # Update a variable
-fj actions variable update MY_VAR "new value"
+fgj actions variable update MY_VAR "new value"
 
 # Delete a variable
-fj actions variable delete MY_VAR
-```
-
-### Raw API Access
-
-```bash
-# GET request (auto-detects owner/repo from git context)
-fj api /repos/{owner}/{repo}/pulls
-
-# POST with fields
-fj api /repos/{owner}/{repo}/issues -X POST -f title="Bug report" -f body="Description"
-
-# Explicit method and hostname
-fj api /repos/myorg/myrepo/labels --hostname my-forgejo.example.com
-
-# Read request body from file
-fj api /repos/{owner}/{repo}/issues -X POST --input issue.json
-
-# Read from stdin
-echo '{"title":"test"}' | fj api /repos/{owner}/{repo}/issues -X POST --input -
-
-# Include response headers
-fj api /repos/{owner}/{repo} -i
-
-# Suppress output (useful for DELETE)
-fj api /repos/{owner}/{repo}/issues/123 -X DELETE --silent
-```
-
-## Shell Completions and Man Pages
-
-```bash
-# Generate shell completion scripts
-fj completion bash > /etc/bash_completion.d/fj
-fj completion zsh > "${fpath[1]}/_fj"
-fj completion fish > ~/.config/fish/completions/fj.fish
-
-# Generate man pages to a directory
-fj manpages --dir ~/.local/share/man/man1
-```
-
-## JSON Output
-
-Most list and view commands support `--json` for machine-readable output:
-
-```bash
-fj pr list --json
-fj issue view 456 --json
-fj release list --json
-fj actions run list --json
-fj actions workflow view ci.yml --json
-
-# Get JSON output from PR comment/review
-fj pr comment 123 -b "LGTM" --json
-fj pr review 123 --approve -b "Ship it" --json
-```
-
-### Structured Error Output
-
-For machine consumption (ideal for AI agents and scripts), use `--json-errors` to get structured JSON errors on stderr:
-
-```bash
-# Errors are written to stderr as JSON
-fj pr view 9999 --json-errors
-# stderr: {"error":{"code":"not_found","message":"...","status":404}}
-
-# Combine with --json for fully machine-readable I/O
-fj pr list --json --json-errors
+fgj actions variable delete MY_VAR
 ```
 
 ## Configuration
 
-Configuration is stored in `~/.config/fj/config.yaml`:
+Configuration is stored in `~/.config/fgj/config.yaml`:
 
 ```yaml
 hosts:
-  forgejo.zerova.net:
-    hostname: forgejo.zerova.net
-    token: your_token_here
-    user: your_username
-    git_protocol: ssh
-    match_dirs:
-      - /              # catch-all: use this host when no git remote is detected
   codeberg.org:
     hostname: codeberg.org
+    token: your_token_here
+    user: your_username
+    git_protocol: https
+  my-forgejo.com:
+    hostname: my-forgejo.com
     token: another_token
     user: another_username
-    git_protocol: https
-    match_dirs:
-      - ~/repos/codeberg   # use this host for repos under this directory
+    git_protocol: ssh
 ```
 
-### Directory-Based Host Selection (`match_dirs`)
-
-When you work with multiple Forgejo/Gitea instances, `fj` can automatically select the right host based on your current working directory — no `--hostname` flag needed.
-
-Each host entry supports a `match_dirs` list of directory paths. When `fj` can't determine the host from a git remote, it finds the host whose `match_dirs` entry is the **longest prefix match** for your current directory.
-
-```yaml
-hosts:
-  work.example.com:
-    # ...
-    match_dirs:
-      - ~/work          # any repo under ~/work uses this host
-  personal.example.com:
-    # ...
-    match_dirs:
-      - ~/personal
-      - ~/side-projects  # multiple directories can map to the same host
-  codeberg.org:
-    # ...
-    match_dirs:
-      - /                # catch-all fallback (shortest prefix, lowest priority)
-```
-
-- Paths support `~` expansion and symlink resolution
-- More specific (longer) paths always win over shorter ones
-- Use `/` as a catch-all to override the default `codeberg.org` fallback
-- On ties (same prefix length), the host appearing first in the config file wins
-
 ### Environment Variables
 
-- `FJ_HOST`: Override the default instance (auto-detected from git remote if not set)
-- `FJ_TOKEN`: Provide authentication token
-
-Hostname is resolved in this priority order:
-1. Command-specific flags (e.g., `--hostname`)
-2. `FJ_HOST` environment variable
-3. Auto-detected from git remote URL
-4. `match_dirs` lookup (longest prefix match against current directory)
-5. Default to `codeberg.org`
+- `FGJ_HOST`: Override the default Forgejo instance
+- `FGJ_TOKEN`: Provide authentication token
 
 ### Command-line Flags
 
-- `--hostname`: Specify instance for a command (overrides auto-detection and environment variables)
+- `--hostname`: Specify Forgejo instance for a command
 - `--config`: Use a custom config file
 
-When working in a git repository, `fj` automatically detects the instance from your origin remote URL, so you typically don't need to specify `--hostname` unless working with multiple instances.
-
 ## Use with AI Coding Agents
 
-`fj` is designed to work seamlessly with AI coding agents like Claude Code. Use `--json` and `--json-errors` for fully machine-readable I/O:
+`fgj` is designed to work seamlessly with AI coding agents like Claude Code. Common patterns:
 
 ```bash
 # Create PR from agent's changes
-fj pr create -R owner/repo -t "feat: add new feature" -b "$(cat <<EOF
+fgj pr create -R owner/repo -t "feat: add new feature" -b "$(cat <<EOF
 ## Summary
 - Added new feature X
 - Fixed bug Y
 
 Generated with AI assistance
 EOF
-)" --json
+)"
 
 # Check PR status during development
-fj pr list -R owner/repo --state open --json
+fgj pr list -R owner/repo --state open
 
-# Review a PR diff, then approve
-fj pr diff 123
-fj pr review 123 --approve -b "LGTM" --json
-
-# Post review feedback
-fj pr comment 123 -b "Consider using a map here for O(1) lookup" --json
-
-# Request changes with detailed feedback
-fj pr review 123 --request-changes --body-file feedback.md --json
-
-# Use raw API for anything not covered by commands
-fj api /repos/{owner}/{repo}/topics --json-errors
-fj api /repos/{owner}/{repo}/labels -X POST -f name=agent-reviewed -f color="#00ff00"
-
-# Fully machine-readable error handling
-fj pr view 9999 --json --json-errors 2>errors.json
+# View PR details for review
+fgj pr view 123 -R owner/repo
 ```
 
-## Supported Instances
+## Supported Forgejo Instances
 
-`fj` works with any Forgejo or Gitea instance, including:
+`fgj` works with any Forgejo instance, including:
 
+- [Codeberg.org](https://codeberg.org) (default)
 - Self-hosted Forgejo instances
-- Self-hosted Gitea instances
-- [Codeberg.org](https://codeberg.org)
+- Gitea instances (compatible API)
+
+## Development
+
+### Building
+
+```bash
+go build -o fgj
+```
+
+### Testing
+
+```bash
+go test ./...
+```
+
+### Project Structure
+
+```
+fgj/
+├── cmd/                 # Command implementations
+│   ├── root.go         # Root command and config
+│   ├── auth.go         # Authentication commands
+│   ├── pr.go           # Pull request commands
+│   ├── issue.go        # Issue commands
+│   └── repo.go         # Repository commands
+├── internal/
+│   ├── api/            # API client wrapper
+│   ├── config/         # Configuration management
+│   └── git/            # Git repository detection
+├── main.go             # Entry point
+└── go.mod              # Dependencies
+```
 
 ## Contributing
 
-Contributions are welcome! Please feel free to submit a Pull Request at [forgejo.zerova.net/public/fj](https://forgejo.zerova.net/public/fj).
-
-## Missing Features / Roadmap
-
-`fj` aims to be a drop-in replacement for `gh` when working with Forgejo and Gitea instances. While we've implemented the core features, some `gh` commands are not yet available:
-
-**Not Yet Implemented:**
-- `run delete` - Delete a workflow run
-- `run download` - Download workflow run artifacts
-- `pr checkout`, `pr close/reopen`
-- `pr checks`, `pr ready/draft`
-- `issue reopen`, `issue assign`
-- `release edit`, `release download`, `release generate-notes`
-- `repo delete`
-
-We welcome contributions to implement any of these features!
-
-## Acknowledgments
-
-Based on [fj by romaintb](https://codeberg.org/romaintb/fj). Enhanced with agentic dev features for AI-assisted workflows.
+Contributions are welcome! Please feel free to submit a Pull Request.
 
 ## License
 
 MIT License
+
+## Acknowledgments
+
+- Inspired by GitHub's `gh` CLI tool
+- Built using the [Gitea SDK](https://code.gitea.io/sdk) (compatible with Forgejo)
+- Uses [Cobra](https://github.com/spf13/cobra) for CLI framework
diff --git a/cmd/actions.go b/cmd/actions.go
index 172831c..e9dbba0 100644
--- a/cmd/actions.go
+++ b/cmd/actions.go
@@ -2,31 +2,31 @@ package cmd
 
 import (
 	"fmt"
-	"net/http"
+	"os"
 	"strconv"
-	"strings"
+	"text/tabwriter"
 	"time"
 
 	"code.gitea.io/sdk/gitea"
 	"github.com/spf13/cobra"
 
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
+	"codeberg.org/romaintb/fgj/internal/api"
+	"codeberg.org/romaintb/fgj/internal/config"
 )
 
 // ActionRun represents a workflow run
 type ActionRun struct {
-	ID          int64  `json:"id"`
-	Title       string `json:"title"`
-	WorkflowID  string `json:"workflow_id"`
-	IndexInRepo int64  `json:"index_in_repo"`
-	Event       string `json:"event"`
-	Status      string `json:"status"`
-	CommitSHA   string `json:"commit_sha"`
-	PrettyRef   string `json:"prettyref"`
-	Created     string `json:"created"`
-	Updated     string `json:"updated"`
-	Started     string `json:"started"`
+	ID          int64     `json:"id"`
+	Title       string    `json:"title"`
+	WorkflowID  string    `json:"workflow_id"`
+	IndexInRepo int64     `json:"index_in_repo"`
+	Event       string    `json:"event"`
+	Status      string    `json:"status"`
+	CommitSHA   string    `json:"commit_sha"`
+	PrettyRef   string    `json:"prettyref"`
+	Created     string    `json:"created"`
+	Updated     string    `json:"updated"`
+	Started     string    `json:"started"`
 }
 
 // ActionRunList represents a list of workflow runs
@@ -37,19 +37,19 @@ type ActionRunList struct {
 
 // ActionTask represents a job/task within a workflow run
 type ActionTask struct {
-	ID           int64  `json:"id"`
-	Name         string `json:"name"`
-	HeadBranch   string `json:"head_branch"`
-	HeadSHA      string `json:"head_sha"`
-	RunNumber    int64  `json:"run_number"`
-	Event        string `json:"event"`
-	DisplayTitle string `json:"display_title"`
-	Status       string `json:"status"`
-	WorkflowID   string `json:"workflow_id"`
-	URL          string `json:"url"`
-	CreatedAt    string `json:"created_at"`
-	UpdatedAt    string `json:"updated_at"`
-	RunStartedAt string `json:"run_started_at"`
+	ID            int64  `json:"id"`
+	Name          string `json:"name"`
+	HeadBranch    string `json:"head_branch"`
+	HeadSHA       string `json:"head_sha"`
+	RunNumber     int64  `json:"run_number"`
+	Event         string `json:"event"`
+	DisplayTitle  string `json:"display_title"`
+	Status        string `json:"status"`
+	WorkflowID    string `json:"workflow_id"`
+	URL           string `json:"url"`
+	CreatedAt     string `json:"created_at"`
+	UpdatedAt     string `json:"updated_at"`
+	RunStartedAt  string `json:"run_started_at"`
 }
 
 // ActionTaskList represents a list of tasks/jobs
@@ -58,28 +58,6 @@ type ActionTaskList struct {
 	TotalCount   int          `json:"total_count"`
 }
 
-// Workflow represents a workflow definition
-type Workflow struct {
-	ID    int64  `json:"id"`
-	Name  string `json:"name"`
-	Path  string `json:"path"`
-	State string `json:"state"`
-}
-
-// WorkflowList represents a list of workflows
-type WorkflowList struct {
-	Workflows  []Workflow `json:"workflows"`
-	TotalCount int        `json:"total_count"`
-}
-
-// ContentsResponse represents a file/directory in the repository
-type ContentsResponse struct {
-	Name string `json:"name"`
-	Path string `json:"path"`
-	Type string `json:"type"`
-	Size int64  `json:"size"`
-}
-
 var actionsCmd = &cobra.Command{
 	Use:     "actions",
 	Aliases: []string{"action"},
@@ -87,224 +65,26 @@ var actionsCmd = &cobra.Command{
 	Long:    "View and manage workflows, runs, secrets, and variables for Forgejo Actions in your repositories.",
 }
 
-// Run and Workflow command trees are built via factory functions
-// (newRunCmd / newWorkflowCmd) so cmd/aliases.go can build an identical
-// top-level tree under rootCmd without duplicating Use/Short/Long/Example/
-// flag declarations. Single source of truth — drift impossible.
-
-// newRunCmd builds the `run` subtree. parentLabel is interpolated into the
-// parent's Short/Long so the alias-tree variant can advertise itself as
-// "alias for 'actions run'" without diverging on the children.
-func newRunCmd(parentLabel string) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "run",
-		Short: "View and manage workflow runs" + parentLabel,
-		Long:  "List, view, and manage workflow runs." + parentLabel,
-	}
-	cmd.AddCommand(newRunListCmd())
-	cmd.AddCommand(newRunViewCmd())
-	cmd.AddCommand(newRunWatchCmd())
-	cmd.AddCommand(newRunRerunCmd())
-	cmd.AddCommand(newRunCancelCmd())
-	return cmd
+// Run commands (compatible with gh run)
+var runCmd = &cobra.Command{
+	Use:   "run",
+	Short: "View and manage workflow runs",
+	Long:  "List, view, and manage workflow runs.",
 }
 
-func newRunListCmd() *cobra.Command {
-	c := &cobra.Command{
-		Use:   "list",
-		Short: "List recent workflow runs",
-		Long:  "List recent workflow runs for a repository.",
-		Example: `  # List recent workflow runs
-  fj actions run list
-
-  # List runs with a custom limit
-  fj actions run list -L 50
-
-  # Output as JSON
-  fj actions run list --json`,
-		RunE: runRunList,
-	}
-	addRepoFlags(c)
-	c.Flags().IntP("limit", "L", 20, "Maximum number of runs to list")
-	addJSONFlags(c, "Output workflow runs as JSON")
-	return c
+var runListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List recent workflow runs",
+	Long:  "List recent workflow runs for a repository.",
+	RunE:  runRunList,
 }
 
-func newRunViewCmd() *cobra.Command {
-	c := &cobra.Command{
-		Use:   "view <run-id>",
-		Short: "View a workflow run",
-		Long:  "View details about a specific workflow run.",
-		Example: `  # View a workflow run
-  fj actions run view 123
-
-  # View with job details
-  fj actions run view 123 -v
-
-  # View logs for a specific job
-  fj actions run view 123 --job 456 --log
-
-  # View only failed logs
-  fj actions run view 123 --log-failed`,
-		Args: cobra.ExactArgs(1),
-		RunE: runRunView,
-	}
-	addRepoFlags(c)
-	c.Flags().BoolP("verbose", "v", false, "Show job steps")
-	c.Flags().BoolP("log", "", false, "View full log for either a run or specific job")
-	c.Flags().StringP("job", "j", "", "View a specific job ID from a run")
-	c.Flags().BoolP("log-failed", "", false, "View the log for any failed steps in a run or specific job")
-	addJSONFlags(c, "Output workflow run as JSON")
-	return c
-}
-
-func newRunWatchCmd() *cobra.Command {
-	c := &cobra.Command{
-		Use:   "watch <run-id>",
-		Short: "Watch a workflow run",
-		Long:  "Poll a workflow run until it completes.",
-		Example: `  # Watch a run until it completes
-  fj actions run watch 123
-
-  # Watch with a custom polling interval
-  fj actions run watch 123 -i 10s`,
-		Args: cobra.ExactArgs(1),
-		RunE: runRunWatch,
-	}
-	addRepoFlags(c)
-	c.Flags().DurationP("interval", "i", 5*time.Second, "Polling interval")
-	return c
-}
-
-func newRunRerunCmd() *cobra.Command {
-	c := &cobra.Command{
-		Use:   "rerun <run-id>",
-		Short: "Rerun a workflow run",
-		Long:  "Trigger a rerun for a specific workflow run.",
-		Example: `  # Rerun a failed workflow run
-  fj actions run rerun 123`,
-		Args: cobra.ExactArgs(1),
-		RunE: runRunRerun,
-	}
-	addRepoFlags(c)
-	return c
-}
-
-func newRunCancelCmd() *cobra.Command {
-	c := &cobra.Command{
-		Use:   "cancel <run-id>",
-		Short: "Cancel a workflow run",
-		Long:  "Cancel a running workflow run.",
-		Example: `  # Cancel a running workflow
-  fj actions run cancel 123`,
-		Args: cobra.ExactArgs(1),
-		RunE: runRunCancel,
-	}
-	addRepoFlags(c)
-	return c
-}
-
-// newWorkflowCmd builds the `workflow` subtree. parentLabel is interpolated
-// the same way as newRunCmd's, so the alias variant can self-identify.
-func newWorkflowCmd(parentLabel string) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "workflow",
-		Short: "Manage workflows" + parentLabel,
-		Long:  "List, view, and run workflows." + parentLabel,
-	}
-	cmd.AddCommand(newWorkflowListCmd())
-	cmd.AddCommand(newWorkflowViewCmd())
-	cmd.AddCommand(newWorkflowRunCmd())
-	cmd.AddCommand(newWorkflowEnableCmd())
-	cmd.AddCommand(newWorkflowDisableCmd())
-	return cmd
-}
-
-func newWorkflowListCmd() *cobra.Command {
-	c := &cobra.Command{
-		Use:   "list",
-		Short: "List workflows",
-		Long:  "List all workflows in a repository.",
-		Example: `  # List all workflows
-  fj actions workflow list
-
-  # List workflows as JSON
-  fj actions workflow list --json
-
-  # List workflows for a specific repo
-  fj actions workflow list -R owner/repo`,
-		RunE: runWorkflowList,
-	}
-	addRepoFlags(c)
-	c.Flags().IntP("limit", "L", 20, "Maximum number of workflows to list")
-	addJSONFlags(c, "Output workflows as JSON")
-	return c
-}
-
-func newWorkflowViewCmd() *cobra.Command {
-	c := &cobra.Command{
-		Use:   "view <workflow>",
-		Short: "View a workflow",
-		Long:  "View details about a specific workflow. You can specify the workflow by name or filename.",
-		Example: `  # View a workflow by filename
-  fj actions workflow view ci.yml
-
-  # View as JSON
-  fj actions workflow view ci.yml --json`,
-		Args: cobra.ExactArgs(1),
-		RunE: runWorkflowView,
-	}
-	addRepoFlags(c)
-	addJSONFlags(c, "Output workflow as JSON")
-	return c
-}
-
-func newWorkflowRunCmd() *cobra.Command {
-	c := &cobra.Command{
-		Use:   "run <workflow>",
-		Short: "Run a workflow",
-		Long:  "Trigger a workflow_dispatch event for a workflow. The workflow must support the workflow_dispatch trigger.",
-		Example: `  # Trigger a workflow on the default branch
-  fj actions workflow run deploy.yml
-
-  # Trigger on a specific branch with input parameters
-  fj actions workflow run deploy.yml -r staging -f environment=staging -f version=1.2.3`,
-		Args: cobra.ExactArgs(1),
-		RunE: runWorkflowRun,
-	}
-	addRepoFlags(c)
-	c.Flags().StringP("ref", "r", "", "Branch or tag name to run the workflow on (defaults to repository's default branch)")
-	c.Flags().StringSliceP("field", "f", nil, "Add a string parameter in key=value format (can be used multiple times)")
-	c.Flags().StringSliceP("raw-field", "F", nil, "Add a string parameter in key=value format, reading from file if value starts with @ (can be used multiple times)")
-	return c
-}
-
-func newWorkflowEnableCmd() *cobra.Command {
-	c := &cobra.Command{
-		Use:   "enable <workflow>",
-		Short: "Enable a workflow",
-		Long:  "Enable a workflow so it can be triggered.\n\nNote: This feature requires Forgejo 15.0+ or Gitea 1.24+.\nFor older versions, use the web UI to enable workflows.",
-		Example: `  # Enable a workflow
-  fj actions workflow enable ci.yml`,
-		Args: cobra.ExactArgs(1),
-		RunE: runWorkflowEnable,
-	}
-	addRepoFlags(c)
-	return c
-}
-
-func newWorkflowDisableCmd() *cobra.Command {
-	c := &cobra.Command{
-		Use:   "disable <workflow>",
-		Short: "Disable a workflow",
-		Long:  "Disable a workflow so it cannot be triggered.\n\nNote: This feature requires Forgejo 15.0+ or Gitea 1.24+.\nFor older versions, use the web UI to disable workflows.",
-		Example: `  # Disable a workflow
-  fj actions workflow disable ci.yml`,
-		Args: cobra.ExactArgs(1),
-		RunE: runWorkflowDisable,
-	}
-	addRepoFlags(c)
-	return c
+var runViewCmd = &cobra.Command{
+	Use:   "view <run-id>",
+	Short: "View a workflow run",
+	Long:  "View details about a specific workflow run.",
+	Args:  cobra.ExactArgs(1),
+	RunE:  runRunView,
 }
 
 // Secret commands
@@ -318,35 +98,23 @@ var actionsSecretListCmd = &cobra.Command{
 	Use:   "list",
 	Short: "List repository secrets",
 	Long:  "List all secrets for a repository.",
-	Example: `  # List all secrets
-  fj actions secret list
-
-  # List secrets for a specific repo
-  fj actions secret list -R owner/repo`,
-	RunE: runActionsSecretList,
+	RunE:  runActionsSecretList,
 }
 
 var actionsSecretCreateCmd = &cobra.Command{
 	Use:   "create <name>",
 	Short: "Create or update a repository secret",
 	Long:  "Create or update a secret for Forgejo Actions. The secret value will be read from stdin.",
-	Example: `  # Create a secret (will prompt for value)
-  fj actions secret create DEPLOY_TOKEN
-
-  # Create a secret for a specific repo
-  fj actions secret create API_KEY -R owner/repo`,
-	Args: cobra.ExactArgs(1),
-	RunE: runActionsSecretCreate,
+	Args:  cobra.ExactArgs(1),
+	RunE:  runActionsSecretCreate,
 }
 
 var actionsSecretDeleteCmd = &cobra.Command{
 	Use:   "delete <name>",
 	Short: "Delete a repository secret",
 	Long:  "Delete a secret from Forgejo Actions.",
-	Example: `  # Delete a secret
-  fj actions secret delete DEPLOY_TOKEN`,
-	Args: cobra.ExactArgs(1),
-	RunE: runActionsSecretDelete,
+	Args:  cobra.ExactArgs(1),
+	RunE:  runActionsSecretDelete,
 }
 
 // Variable commands
@@ -360,64 +128,48 @@ var actionsVariableListCmd = &cobra.Command{
 	Use:   "list",
 	Short: "List repository variables",
 	Long:  "List all variables for a repository.",
-	Example: `  # List all variables
-  fj actions variable list
-
-  # List variables for a specific repo
-  fj actions variable list -R owner/repo`,
-	RunE: runActionsVariableList,
+	RunE:  runActionsVariableList,
 }
 
 var actionsVariableGetCmd = &cobra.Command{
 	Use:   "get <name>",
 	Short: "Get a repository variable",
 	Long:  "Get the value of a specific repository variable.",
-	Example: `  # Get a variable value
-  fj actions variable get ENVIRONMENT`,
-	Args: cobra.ExactArgs(1),
-	RunE: runActionsVariableGet,
+	Args:  cobra.ExactArgs(1),
+	RunE:  runActionsVariableGet,
 }
 
 var actionsVariableCreateCmd = &cobra.Command{
 	Use:   "create <name> <value>",
 	Short: "Create a repository variable",
 	Long:  "Create a new variable for Forgejo Actions.",
-	Example: `  # Create a variable
-  fj actions variable create ENVIRONMENT production
-
-  # Create a variable for a specific repo
-  fj actions variable create NODE_VERSION 20 -R owner/repo`,
-	Args: cobra.ExactArgs(2),
-	RunE: runActionsVariableCreate,
+	Args:  cobra.ExactArgs(2),
+	RunE:  runActionsVariableCreate,
 }
 
 var actionsVariableUpdateCmd = &cobra.Command{
 	Use:   "update <name> <value>",
 	Short: "Update a repository variable",
 	Long:  "Update an existing variable for Forgejo Actions.",
-	Example: `  # Update a variable
-  fj actions variable update ENVIRONMENT staging`,
-	Args: cobra.ExactArgs(2),
-	RunE: runActionsVariableUpdate,
+	Args:  cobra.ExactArgs(2),
+	RunE:  runActionsVariableUpdate,
 }
 
 var actionsVariableDeleteCmd = &cobra.Command{
 	Use:   "delete <name>",
 	Short: "Delete a repository variable",
 	Long:  "Delete a variable from Forgejo Actions.",
-	Example: `  # Delete a variable
-  fj actions variable delete ENVIRONMENT`,
-	Args: cobra.ExactArgs(1),
-	RunE: runActionsVariableDelete,
+	Args:  cobra.ExactArgs(1),
+	RunE:  runActionsVariableDelete,
 }
 
 func init() {
 	rootCmd.AddCommand(actionsCmd)
 
-	// Run and Workflow trees come from the factory functions defined above
-	// so cmd/aliases.go can build identical top-level trees under rootCmd.
-	actionsCmd.AddCommand(newRunCmd(""))
-	actionsCmd.AddCommand(newWorkflowCmd(""))
+	// Add run commands (gh run compatible)
+	actionsCmd.AddCommand(runCmd)
+	runCmd.AddCommand(runListCmd)
+	runCmd.AddCommand(runViewCmd)
 
 	// Add secret commands
 	actionsCmd.AddCommand(actionsSecretCmd)
@@ -433,6 +185,15 @@ func init() {
 	actionsVariableCmd.AddCommand(actionsVariableUpdateCmd)
 	actionsVariableCmd.AddCommand(actionsVariableDeleteCmd)
 
+	// Add flags for run commands
+	addRepoFlags(runListCmd)
+	runListCmd.Flags().IntP("limit", "L", 20, "Maximum number of runs to list")
+	addRepoFlags(runViewCmd)
+	runViewCmd.Flags().BoolP("verbose", "v", false, "Show job steps")
+	runViewCmd.Flags().BoolP("log", "", false, "View full log for either a run or specific job")
+	runViewCmd.Flags().StringP("job", "j", "", "View a specific job ID from a run")
+	runViewCmd.Flags().BoolP("log-failed", "", false, "View the log for any failed steps in a run or specific job")
+
 	// Add flags for secret commands
 	addRepoFlags(actionsSecretListCmd)
 	addRepoFlags(actionsSecretCreateCmd)
@@ -440,7 +201,6 @@ func init() {
 
 	// Add flags for variable commands
 	addRepoFlags(actionsVariableListCmd)
-	addJSONFlags(actionsVariableListCmd, "Output variables as JSON")
 	addRepoFlags(actionsVariableGetCmd)
 	addRepoFlags(actionsVariableCreateCmd)
 	addRepoFlags(actionsVariableUpdateCmd)
@@ -459,7 +219,7 @@ func runRunList(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to load config: %w", err)
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return fmt.Errorf("failed to create client: %w", err)
 	}
@@ -480,26 +240,35 @@ func runRunList(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to list runs: %w", err)
 	}
 
-	if wantJSON(cmd) {
-		return outputJSON(cmd, runList.WorkflowRuns)
-	}
-
 	if len(runList.WorkflowRuns) == 0 {
-		fmt.Fprintln(ios.Out, "No workflow runs found")
+		fmt.Println("No workflow runs found")
 		return nil
 	}
 
-	tp := ios.NewTablePrinter()
-	tp.AddHeader("STATUS", "TITLE", "WORKFLOW", "EVENT", "ID", "CREATED")
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+	if _, err := fmt.Fprintln(w, "STATUS\tTITLE\tWORKFLOW\tEVENT\tID\tCREATED"); err != nil {
+		return fmt.Errorf("failed to write header: %w", err)
+	}
+
 	for _, run := range runList.WorkflowRuns {
 		createdTime, err := time.Parse(time.RFC3339, run.Created)
 		if err != nil {
 			createdTime = time.Now()
 		}
+
 		timeStr := formatTimeSince(createdTime)
-		tp.AddRow(formatStatus(run.Status), run.Title, run.WorkflowID, run.Event, fmt.Sprintf("%d", run.ID), timeStr)
+
+		if _, err := fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%d\t%s\n",
+			formatStatus(run.Status), run.Title, run.WorkflowID, run.Event, run.ID, timeStr); err != nil {
+			return fmt.Errorf("failed to write run: %w", err)
+		}
 	}
-	return tp.Render()
+
+	if err := w.Flush(); err != nil {
+		return fmt.Errorf("failed to flush output: %w", err)
+	}
+
+	return nil
 }
 
 func runRunView(cmd *cobra.Command, args []string) error {
@@ -508,7 +277,7 @@ func runRunView(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to load config: %w", err)
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return fmt.Errorf("failed to create client: %w", err)
 	}
@@ -528,7 +297,6 @@ func runRunView(cmd *cobra.Command, args []string) error {
 	showLog, _ := cmd.Flags().GetBool("log")
 	jobIDStr, _ := cmd.Flags().GetString("job")
 	showLogFailed, _ := cmd.Flags().GetBool("log-failed")
-	jsonRequested := wantJSON(cmd)
 
 	var jobID int64
 	if jobIDStr != "" {
@@ -539,10 +307,6 @@ func runRunView(cmd *cobra.Command, args []string) error {
 		}
 	}
 
-	if jsonRequested && (showLog || showLogFailed) {
-		return fmt.Errorf("--json cannot be used with --log or --log-failed")
-	}
-
 	// Call the API endpoint directly since SDK doesn't have it yet
 	endpoint := fmt.Sprintf("/api/v1/repos/%s/%s/actions/runs/%d", owner, name, runID)
 
@@ -551,75 +315,34 @@ func runRunView(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to get run: %w", err)
 	}
 
-	needsJobs := verbose || showLog || showLogFailed || jobID > 0
-
-	if jsonRequested {
-		var runTasks []ActionTask
-		if needsJobs {
-			tasksEndpoint := fmt.Sprintf("/api/v1/repos/%s/%s/actions/tasks", owner, name)
-			var taskList ActionTaskList
-			if err := client.GetJSON(tasksEndpoint, &taskList); err != nil {
-				return fmt.Errorf("failed to get tasks: %w", err)
-			}
-
-			for _, task := range taskList.WorkflowRuns {
-				if task.RunNumber == run.IndexInRepo {
-					runTasks = append(runTasks, task)
-				}
-			}
-
-			if jobID > 0 {
-				var filtered []ActionTask
-				for _, task := range runTasks {
-					if task.ID == jobID {
-						filtered = append(filtered, task)
-						break
-					}
-				}
-				if len(filtered) == 0 {
-					return fmt.Errorf("job %d not found in this run", jobID)
-				}
-				runTasks = filtered
-			}
-		}
-
-		payload := struct {
-			Run   ActionRun    `json:"run"`
-			Tasks []ActionTask `json:"tasks,omitempty"`
-		}{
-			Run:   run,
-			Tasks: runTasks,
-		}
-		return outputJSON(cmd, payload)
-	}
-
 	// Display run information
-	fmt.Fprintf(ios.Out, "Title: %s\n", run.Title)
-	fmt.Fprintf(ios.Out, "Workflow: %s\n", run.WorkflowID)
-	fmt.Fprintf(ios.Out, "Run: #%d\n", run.IndexInRepo)
-	fmt.Fprintf(ios.Out, "Status: %s\n", formatStatus(run.Status))
-	fmt.Fprintf(ios.Out, "Event: %s\n", run.Event)
-	fmt.Fprintf(ios.Out, "Ref: %s\n", run.PrettyRef)
+	fmt.Printf("Title: %s\n", run.Title)
+	fmt.Printf("Workflow: %s\n", run.WorkflowID)
+	fmt.Printf("Run: #%d\n", run.IndexInRepo)
+	fmt.Printf("Status: %s\n", formatStatus(run.Status))
+	fmt.Printf("Event: %s\n", run.Event)
+	fmt.Printf("Ref: %s\n", run.PrettyRef)
 
 	commit := run.CommitSHA
 	if len(commit) > 8 {
 		commit = commit[:8]
 	}
-	fmt.Fprintf(ios.Out, "Commit: %s\n", commit)
+	fmt.Printf("Commit: %s\n", commit)
 
 	if createdTime, err := time.Parse(time.RFC3339, run.Created); err == nil {
-		fmt.Fprintf(ios.Out, "Created: %s\n", createdTime.Format("2006-01-02 15:04:05"))
+		fmt.Printf("Created: %s\n", createdTime.Format("2006-01-02 15:04:05"))
 	}
 	if run.Started != "" {
 		if startedTime, err := time.Parse(time.RFC3339, run.Started); err == nil {
-			fmt.Fprintf(ios.Out, "Started: %s\n", startedTime.Format("2006-01-02 15:04:05"))
+			fmt.Printf("Started: %s\n", startedTime.Format("2006-01-02 15:04:05"))
 		}
 	}
 	if updatedTime, err := time.Parse(time.RFC3339, run.Updated); err == nil {
-		fmt.Fprintf(ios.Out, "Updated: %s\n", updatedTime.Format("2006-01-02 15:04:05"))
+		fmt.Printf("Updated: %s\n", updatedTime.Format("2006-01-02 15:04:05"))
 	}
 
 	// Fetch jobs if needed for verbose, log, or job-specific views
+	needsJobs := verbose || showLog || showLogFailed || jobID > 0
 	if !needsJobs {
 		return nil
 	}
@@ -639,7 +362,7 @@ func runRunView(cmd *cobra.Command, args []string) error {
 	}
 
 	if len(runTasks) == 0 {
-		fmt.Fprintln(ios.Out, "\nNo jobs found for this run")
+		fmt.Println("\nNo jobs found for this run")
 		return nil
 	}
 
@@ -660,14 +383,14 @@ func runRunView(cmd *cobra.Command, args []string) error {
 
 	// Case 1: --verbose (show job steps/details without logs)
 	if verbose && !showLog && !showLogFailed {
-		fmt.Fprintln(ios.Out, "\nJobs:")
+		fmt.Println("\nJobs:")
 		for _, task := range runTasks {
-			fmt.Fprintf(ios.Out, "\n  %s - %s (ID: %d)\n", formatStatus(task.Status), task.Name, task.ID)
+			fmt.Printf("\n  %s - %s (ID: %d)\n", formatStatus(task.Status), task.Name, task.ID)
 			if startedTime, err := time.Parse(time.RFC3339, task.RunStartedAt); err == nil {
-				fmt.Fprintf(ios.Out, "    Started: %s\n", startedTime.Format("2006-01-02 15:04:05"))
+				fmt.Printf("    Started: %s\n", startedTime.Format("2006-01-02 15:04:05"))
 			}
 			if updatedTime, err := time.Parse(time.RFC3339, task.UpdatedAt); err == nil {
-				fmt.Fprintf(ios.Out, "    Updated: %s\n", updatedTime.Format("2006-01-02 15:04:05"))
+				fmt.Printf("    Updated: %s\n", updatedTime.Format("2006-01-02 15:04:05"))
 			}
 		}
 		return nil
@@ -676,8 +399,8 @@ func runRunView(cmd *cobra.Command, args []string) error {
 	// Case 2: --log or --log-failed (show logs)
 	if showLog || showLogFailed {
 		for _, task := range runTasks {
-			if err := showJobLog(client, owner, name, task, showLogFailed); err != nil {
-				fmt.Fprintf(ios.Out, "\nError fetching log for job %s: %v\n", task.Name, err)
+			if err := showJobLog(client, owner, name, run.IndexInRepo, task, showLogFailed); err != nil {
+				fmt.Printf("\nError fetching log for job %s: %v\n", task.Name, err)
 			}
 		}
 		return nil
@@ -686,142 +409,30 @@ func runRunView(cmd *cobra.Command, args []string) error {
 	// Case 3: --job without --log or --verbose (show job details only)
 	if jobID > 0 {
 		task := runTasks[0]
-		fmt.Fprintln(ios.Out, "\nJob Details:")
-		fmt.Fprintf(ios.Out, "  Name: %s\n", task.Name)
-		fmt.Fprintf(ios.Out, "  ID: %d\n", task.ID)
-		fmt.Fprintf(ios.Out, "  Status: %s\n", formatStatus(task.Status))
+		fmt.Println("\nJob Details:")
+		fmt.Printf("  Name: %s\n", task.Name)
+		fmt.Printf("  ID: %d\n", task.ID)
+		fmt.Printf("  Status: %s\n", formatStatus(task.Status))
 		if startedTime, err := time.Parse(time.RFC3339, task.RunStartedAt); err == nil {
-			fmt.Fprintf(ios.Out, "  Started: %s\n", startedTime.Format("2006-01-02 15:04:05"))
+			fmt.Printf("  Started: %s\n", startedTime.Format("2006-01-02 15:04:05"))
 		}
 		if updatedTime, err := time.Parse(time.RFC3339, task.UpdatedAt); err == nil {
-			fmt.Fprintf(ios.Out, "  Updated: %s\n", updatedTime.Format("2006-01-02 15:04:05"))
+			fmt.Printf("  Updated: %s\n", updatedTime.Format("2006-01-02 15:04:05"))
 		}
 	}
 
 	return nil
 }
 
-func runRunWatch(cmd *cobra.Command, args []string) error {
-	cfg, err := config.Load()
-	if err != nil {
-		return fmt.Errorf("failed to load config: %w", err)
-	}
+func showJobLog(client *api.Client, owner, name string, runNumber int64, task ActionTask, logFailed bool) error {
+	// Fetch log from /repos/{owner}/{repo}/actions/runs/{run_number}/jobs/{job_id}/logs
+	logURL := fmt.Sprintf("https://%s/%s/%s/actions/runs/%d/jobs/%d/logs",
+		client.Hostname(), owner, name, runNumber, task.ID)
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return fmt.Errorf("failed to create client: %w", err)
-	}
-
-	repo, _ := cmd.Flags().GetString("repo")
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	runID, err := strconv.ParseInt(args[0], 10, 64)
-	if err != nil {
-		return fmt.Errorf("invalid run ID: %w", err)
-	}
-
-	interval, _ := cmd.Flags().GetDuration("interval")
-	if interval <= 0 {
-		return fmt.Errorf("interval must be greater than 0")
-	}
-
-	endpoint := fmt.Sprintf("/api/v1/repos/%s/%s/actions/runs/%d", owner, name, runID)
-
-	var lastStatus string
-	for {
-		var run ActionRun
-		if err := client.GetJSON(endpoint, &run); err != nil {
-			return fmt.Errorf("failed to get run: %w", err)
-		}
-
-		if run.Status != lastStatus {
-			fmt.Fprintf(ios.Out, "Status: %s\n", formatStatus(run.Status))
-			lastStatus = run.Status
-		}
-
-		if isRunComplete(run.Status) {
-			fmt.Fprintf(ios.Out, "Run #%d completed with status %s\n", run.IndexInRepo, formatStatus(run.Status))
-			return nil
-		}
-
-		time.Sleep(interval)
-	}
-}
-
-func runRunRerun(cmd *cobra.Command, args []string) error {
-	cfg, err := config.Load()
-	if err != nil {
-		return fmt.Errorf("failed to load config: %w", err)
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return fmt.Errorf("failed to create client: %w", err)
-	}
-
-	repo, _ := cmd.Flags().GetString("repo")
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	runID, err := strconv.ParseInt(args[0], 10, 64)
-	if err != nil {
-		return fmt.Errorf("invalid run ID: %w", err)
-	}
-
-	endpoint := fmt.Sprintf("/api/v1/repos/%s/%s/actions/runs/%d/rerun", owner, name, runID)
-	if err := client.PostJSON(endpoint, nil, nil); err != nil {
-		return fmt.Errorf("failed to rerun workflow: %w", err)
-	}
-
-	fmt.Fprintf(ios.Out, "✓ Rerun requested for run %d\n", runID)
-	return nil
-}
-
-func runRunCancel(cmd *cobra.Command, args []string) error {
-	cfg, err := config.Load()
-	if err != nil {
-		return fmt.Errorf("failed to load config: %w", err)
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return fmt.Errorf("failed to create client: %w", err)
-	}
-
-	repo, _ := cmd.Flags().GetString("repo")
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	runID, err := strconv.ParseInt(args[0], 10, 64)
-	if err != nil {
-		return fmt.Errorf("invalid run ID: %w", err)
-	}
-
-	endpoint := fmt.Sprintf("/api/v1/repos/%s/%s/actions/runs/%d/cancel", owner, name, runID)
-	if err := client.PostJSON(endpoint, nil, nil); err != nil {
-		return fmt.Errorf("failed to cancel workflow run: %w", err)
-	}
-
-	fmt.Fprintf(ios.Out, "✓ Cancel requested for run %d\n", runID)
-	return nil
-}
-
-func showJobLog(client *api.Client, owner, name string, task ActionTask, logFailed bool) error {
-	// Fetch log from API: GET /api/v1/repos/{owner}/{repo}/actions/jobs/{job_id}/logs
-	logURL := fmt.Sprintf("https://%s/api/v1/repos/%s/%s/actions/jobs/%d/logs",
-		client.Hostname(), owner, name, task.ID)
-
-	fmt.Fprintf(ios.Out, "\n========================================\n")
-	fmt.Fprintf(ios.Out, "Job: %s (ID: %d)\n", task.Name, task.ID)
-	fmt.Fprintf(ios.Out, "Status: %s\n", formatStatus(task.Status))
-	fmt.Fprintf(ios.Out, "========================================\n\n")
+	fmt.Printf("\n========================================\n")
+	fmt.Printf("Job: %s (ID: %d)\n", task.Name, task.ID)
+	fmt.Printf("Status: %s\n", formatStatus(task.Status))
+	fmt.Printf("========================================\n\n")
 
 	// Use GetRawLog helper
 	logContent, err := client.GetRawLog(logURL)
@@ -834,11 +445,11 @@ func showJobLog(client *api.Client, owner, name string, task ActionTask, logFail
 	if logFailed {
 		// TODO: Implement filtering for failed steps only
 		// This would require parsing the log format and identifying failed step markers
-		fmt.Fprintln(ios.Out, "Note: --log-failed filtering not yet implemented, showing all logs")
+		fmt.Println("Note: --log-failed filtering not yet implemented, showing all logs")
 	}
 
-	fmt.Fprint(ios.Out, logContent)
-	fmt.Fprintln(ios.Out)
+	fmt.Print(logContent)
+	fmt.Println()
 
 	return nil
 }
@@ -862,15 +473,6 @@ func formatStatus(status string) string {
 	}
 }
 
-func isRunComplete(status string) bool {
-	switch status {
-	case "success", "failure", "cancelled", "skipped":
-		return true
-	default:
-		return false
-	}
-}
-
 func formatTimeSince(t time.Time) string {
 	duration := time.Since(t)
 
@@ -897,346 +499,6 @@ func formatTimeSince(t time.Time) string {
 	return fmt.Sprintf("%d days ago", days)
 }
 
-// Workflow command implementations
-
-func runWorkflowList(cmd *cobra.Command, args []string) error {
-	cfg, err := config.Load()
-	if err != nil {
-		return fmt.Errorf("failed to load config: %w", err)
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return fmt.Errorf("failed to create client: %w", err)
-	}
-
-	repo, _ := cmd.Flags().GetString("repo")
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	limit, _ := cmd.Flags().GetInt("limit")
-
-	// List workflows from both .gitea/workflows and .forgejo/workflows
-	var allWorkflows []Workflow
-
-	for _, dir := range []string{".gitea/workflows", ".forgejo/workflows"} {
-		endpoint := fmt.Sprintf("/api/v1/repos/%s/%s/contents/%s", owner, name, dir)
-
-		var contents []ContentsResponse
-		if err := client.GetJSON(endpoint, &contents); err != nil {
-			// Directory might not exist, continue
-			continue
-		}
-
-		for _, content := range contents {
-			if content.Type == "file" && (len(content.Name) > 4 && (content.Name[len(content.Name)-4:] == ".yml" || content.Name[len(content.Name)-5:] == ".yaml")) {
-				workflow := Workflow{
-					Name:  content.Name,
-					Path:  content.Path,
-					State: "active",
-				}
-				allWorkflows = append(allWorkflows, workflow)
-
-				if len(allWorkflows) >= limit {
-					break
-				}
-			}
-		}
-
-		if len(allWorkflows) >= limit {
-			break
-		}
-	}
-
-	if len(allWorkflows) == 0 {
-		if wantJSON(cmd) {
-			return outputJSON(cmd, allWorkflows)
-		}
-		fmt.Fprintln(ios.Out, "No workflows found")
-		return nil
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, allWorkflows)
-	}
-
-	tp := ios.NewTablePrinter()
-	tp.AddHeader("NAME", "STATE", "PATH")
-
-	for _, workflow := range allWorkflows {
-		tp.AddRow(workflow.Name, workflow.State, workflow.Path)
-	}
-
-	return tp.Render()
-}
-
-func runWorkflowView(cmd *cobra.Command, args []string) error {
-	cfg, err := config.Load()
-	if err != nil {
-		return fmt.Errorf("failed to load config: %w", err)
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return fmt.Errorf("failed to create client: %w", err)
-	}
-
-	repo, _ := cmd.Flags().GetString("repo")
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	workflowIdentifier := args[0]
-	workflow, err := findWorkflow(client, owner, name, workflowIdentifier)
-	if err != nil {
-		return err
-	}
-
-	var latestRun *ActionRun
-
-	// Get the latest run for this workflow
-	runsEndpoint := fmt.Sprintf("/api/v1/repos/%s/%s/actions/runs?workflow_id=%s&limit=1", owner, name, workflow.Path)
-	var runList ActionRunList
-	if err := client.GetJSON(runsEndpoint, &runList); err == nil && len(runList.WorkflowRuns) > 0 {
-		latestRun = &runList.WorkflowRuns[0]
-	}
-
-	if wantJSON(cmd) {
-		payload := struct {
-			Workflow  *Workflow  `json:"workflow"`
-			LatestRun *ActionRun `json:"latest_run,omitempty"`
-		}{
-			Workflow:  workflow,
-			LatestRun: latestRun,
-		}
-		return outputJSON(cmd, payload)
-	}
-
-	// Display workflow information
-	fmt.Fprintf(ios.Out, "Name: %s\n", workflow.Name)
-	fmt.Fprintf(ios.Out, "Path: %s\n", workflow.Path)
-	fmt.Fprintf(ios.Out, "State: %s\n", workflow.State)
-
-	if latestRun != nil {
-		fmt.Fprintf(ios.Out, "\nLatest run:\n")
-		fmt.Fprintf(ios.Out, "  Status: %s\n", formatStatus(latestRun.Status))
-		fmt.Fprintf(ios.Out, "  Event: %s\n", latestRun.Event)
-		fmt.Fprintf(ios.Out, "  Ref: %s\n", latestRun.PrettyRef)
-		if createdTime, err := time.Parse(time.RFC3339, latestRun.Created); err == nil {
-			fmt.Fprintf(ios.Out, "  Created: %s\n", formatTimeSince(createdTime))
-		}
-	}
-
-	return nil
-}
-
-func runWorkflowRun(cmd *cobra.Command, args []string) error {
-	cfg, err := config.Load()
-	if err != nil {
-		return fmt.Errorf("failed to load config: %w", err)
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return fmt.Errorf("failed to create client: %w", err)
-	}
-
-	repo, _ := cmd.Flags().GetString("repo")
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	workflowIdentifier := args[0]
-	ref, _ := cmd.Flags().GetString("ref")
-	fields, _ := cmd.Flags().GetStringSlice("field")
-	rawFields, _ := cmd.Flags().GetStringSlice("raw-field")
-
-	// If no ref is specified, get the repository's default branch
-	if ref == "" {
-		repoInfo, _, err := client.GetRepo(owner, name)
-		if err != nil {
-			return fmt.Errorf("failed to get repository info: %w", err)
-		}
-		ref = repoInfo.DefaultBranch
-	}
-
-	// Build the inputs map
-	inputs := make(map[string]string)
-
-	// Process -f/--field flags
-	for _, field := range fields {
-		parts := splitKeyValue(field)
-		if len(parts) == 2 {
-			inputs[parts[0]] = parts[1]
-		}
-	}
-
-	// Process -F/--raw-field flags (same as field for now, file reading can be added later)
-	for _, field := range rawFields {
-		parts := splitKeyValue(field)
-		if len(parts) == 2 {
-			inputs[parts[0]] = parts[1]
-		}
-	}
-
-	// Prepare the dispatch request
-	dispatchReq := map[string]any{
-		"ref": ref,
-	}
-	if len(inputs) > 0 {
-		dispatchReq["inputs"] = inputs
-	}
-
-	// Trigger the workflow
-	endpoint := fmt.Sprintf("/api/v1/repos/%s/%s/actions/workflows/%s/dispatches", owner, name, workflowIdentifier)
-
-	if err := client.PostJSON(endpoint, dispatchReq, nil); err != nil {
-		return fmt.Errorf("failed to trigger workflow: %w", err)
-	}
-
-	fmt.Fprintf(ios.Out, "✓ Workflow '%s' triggered successfully\n", workflowIdentifier)
-	fmt.Fprintf(ios.Out, "  Branch/Tag: %s\n", ref)
-	if len(inputs) > 0 {
-		fmt.Fprintln(ios.Out, "  Inputs:")
-		for key, value := range inputs {
-			fmt.Fprintf(ios.Out, "    %s: %s\n", key, value)
-		}
-	}
-
-	return nil
-}
-
-func runWorkflowEnable(cmd *cobra.Command, args []string) error {
-	cfg, err := config.Load()
-	if err != nil {
-		return fmt.Errorf("failed to load config: %w", err)
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return fmt.Errorf("failed to create client: %w", err)
-	}
-
-	repo, _ := cmd.Flags().GetString("repo")
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	workflowIdentifier := args[0]
-	workflow, err := findWorkflow(client, owner, name, workflowIdentifier)
-	if err != nil {
-		return err
-	}
-
-	endpoint := fmt.Sprintf("/api/v1/repos/%s/%s/actions/workflows/%s/enable", owner, name, workflow.Name)
-
-	// Try PUT first (correct method per GitHub/Gitea API spec)
-	status, err := client.DoJSON(http.MethodPut, endpoint, nil, nil)
-	if err != nil && (status == http.StatusNotFound || status == http.StatusMethodNotAllowed) {
-		// Fall back to POST for older versions
-		status, err = client.DoJSON(http.MethodPost, endpoint, nil, nil)
-	}
-
-	if err != nil {
-		if status == http.StatusNotFound && strings.Contains(err.Error(), "404") {
-			return fmt.Errorf("failed to enable workflow: this feature requires Forgejo 15.0+ or Gitea 1.24+. " +
-				"Your instance does not support the workflow enable/disable API endpoints yet. " +
-				"You can enable workflows via the web UI instead")
-		}
-		return fmt.Errorf("failed to enable workflow: %w", err)
-	}
-
-	fmt.Fprintf(ios.Out, "✓ Workflow '%s' enabled\n", workflow.Name)
-	return nil
-}
-
-func runWorkflowDisable(cmd *cobra.Command, args []string) error {
-	cfg, err := config.Load()
-	if err != nil {
-		return fmt.Errorf("failed to load config: %w", err)
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return fmt.Errorf("failed to create client: %w", err)
-	}
-
-	repo, _ := cmd.Flags().GetString("repo")
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	workflowIdentifier := args[0]
-	workflow, err := findWorkflow(client, owner, name, workflowIdentifier)
-	if err != nil {
-		return err
-	}
-
-	endpoint := fmt.Sprintf("/api/v1/repos/%s/%s/actions/workflows/%s/disable", owner, name, workflow.Name)
-
-	// Try PUT first (correct method per GitHub/Gitea API spec)
-	status, err := client.DoJSON(http.MethodPut, endpoint, nil, nil)
-	if err != nil && (status == http.StatusNotFound || status == http.StatusMethodNotAllowed) {
-		// Fall back to POST for older versions
-		status, err = client.DoJSON(http.MethodPost, endpoint, nil, nil)
-	}
-
-	if err != nil {
-		if status == http.StatusNotFound && strings.Contains(err.Error(), "404") {
-			return fmt.Errorf("failed to disable workflow: this feature requires Forgejo 15.0+ or Gitea 1.24+. " +
-				"Your instance does not support the workflow enable/disable API endpoints yet. " +
-				"You can disable workflows via the web UI instead")
-		}
-		return fmt.Errorf("failed to disable workflow: %w", err)
-	}
-
-	fmt.Fprintf(ios.Out, "✓ Workflow '%s' disabled\n", workflow.Name)
-	return nil
-}
-
-func splitKeyValue(s string) []string {
-	idx := -1
-	for i, c := range s {
-		if c == '=' {
-			idx = i
-			break
-		}
-	}
-	if idx == -1 {
-		return []string{s}
-	}
-	return []string{s[:idx], s[idx+1:]}
-}
-
-func findWorkflow(client *api.Client, owner, name, workflowIdentifier string) (*Workflow, error) {
-	for _, dir := range []string{".gitea/workflows", ".forgejo/workflows"} {
-		endpoint := fmt.Sprintf("/api/v1/repos/%s/%s/contents/%s", owner, name, dir)
-
-		var contents []ContentsResponse
-		if err := client.GetJSON(endpoint, &contents); err != nil {
-			continue
-		}
-
-		for _, content := range contents {
-			if content.Type == "file" && (content.Name == workflowIdentifier || content.Path == workflowIdentifier) {
-				return &Workflow{
-					Name:  content.Name,
-					Path:  content.Path,
-					State: "active",
-				}, nil
-			}
-		}
-	}
-
-	return nil, fmt.Errorf("workflow '%s' not found", workflowIdentifier)
-}
-
 // Secret command implementations
 
 func runActionsSecretList(cmd *cobra.Command, args []string) error {
@@ -1245,7 +507,7 @@ func runActionsSecretList(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to load config: %w", err)
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return fmt.Errorf("failed to create client: %w", err)
 	}
@@ -1262,16 +524,24 @@ func runActionsSecretList(cmd *cobra.Command, args []string) error {
 	}
 
 	if len(secrets) == 0 {
-		fmt.Fprintln(ios.Out, "No secrets found")
+		fmt.Println("No secrets found")
 		return nil
 	}
 
-	tp := ios.NewTablePrinter()
-	tp.AddHeader("NAME", "CREATED")
-	for _, secret := range secrets {
-		tp.AddRow(secret.Name, secret.Created.Format("2006-01-02 15:04:05"))
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+	if _, err := fmt.Fprintln(w, "NAME\tCREATED"); err != nil {
+		return fmt.Errorf("failed to write header: %w", err)
 	}
-	return tp.Render()
+	for _, secret := range secrets {
+		if _, err := fmt.Fprintf(w, "%s\t%s\n", secret.Name, secret.Created.Format("2006-01-02 15:04:05")); err != nil {
+			return fmt.Errorf("failed to write secret: %w", err)
+		}
+	}
+	if err := w.Flush(); err != nil {
+		return fmt.Errorf("failed to flush output: %w", err)
+	}
+
+	return nil
 }
 
 func runActionsSecretCreate(cmd *cobra.Command, args []string) error {
@@ -1280,7 +550,7 @@ func runActionsSecretCreate(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to load config: %w", err)
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return fmt.Errorf("failed to create client: %w", err)
 	}
@@ -1294,7 +564,7 @@ func runActionsSecretCreate(cmd *cobra.Command, args []string) error {
 	secretName := args[0]
 
 	// Read secret value from stdin
-	fmt.Fprint(ios.ErrOut, "Enter secret value: ")
+	fmt.Print("Enter secret value: ")
 	var secretValue string
 	_, err = fmt.Scanln(&secretValue)
 	if err != nil {
@@ -1311,7 +581,7 @@ func runActionsSecretCreate(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to create secret: %w", err)
 	}
 
-	fmt.Fprintf(ios.Out, "Secret '%s' created successfully\n", secretName)
+	fmt.Printf("Secret '%s' created successfully\n", secretName)
 	return nil
 }
 
@@ -1321,7 +591,7 @@ func runActionsSecretDelete(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to load config: %w", err)
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return fmt.Errorf("failed to create client: %w", err)
 	}
@@ -1339,57 +609,15 @@ func runActionsSecretDelete(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to delete secret: %w", err)
 	}
 
-	fmt.Fprintf(ios.Out, "Secret '%s' deleted successfully\n", secretName)
+	fmt.Printf("Secret '%s' deleted successfully\n", secretName)
 	return nil
 }
 
 // Variable command implementations
 
-// ActionVariable represents a repository action variable from the API
-type ActionVariable struct {
-	Name  string `json:"name"`
-	Value string `json:"data"`
-}
-
 func runActionsVariableList(cmd *cobra.Command, args []string) error {
-	cfg, err := config.Load()
-	if err != nil {
-		return fmt.Errorf("failed to load config: %w", err)
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return fmt.Errorf("failed to create client: %w", err)
-	}
-
-	repo, _ := cmd.Flags().GetString("repo")
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	endpoint := fmt.Sprintf("/api/v1/repos/%s/%s/actions/variables", owner, name)
-
-	var variables []ActionVariable
-	if err := client.GetJSON(endpoint, &variables); err != nil {
-		return fmt.Errorf("failed to list variables: %w", err)
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, variables)
-	}
-
-	if len(variables) == 0 {
-		fmt.Fprintln(ios.Out, "No variables found")
-		return nil
-	}
-
-	tp := ios.NewTablePrinter()
-	tp.AddHeader("NAME", "VALUE")
-	for _, v := range variables {
-		tp.AddRow(v.Name, v.Value)
-	}
-	return tp.Render()
+	// Note: The SDK doesn't have a ListRepoActionVariable method yet
+	return fmt.Errorf("listing variables is not yet supported in the SDK")
 }
 
 func runActionsVariableGet(cmd *cobra.Command, args []string) error {
@@ -1398,7 +626,7 @@ func runActionsVariableGet(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to load config: %w", err)
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return fmt.Errorf("failed to create client: %w", err)
 	}
@@ -1416,7 +644,7 @@ func runActionsVariableGet(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to get variable: %w", err)
 	}
 
-	fmt.Fprintf(ios.Out, "%s=%s\n", variable.Name, variable.Value)
+	fmt.Printf("%s=%s\n", variable.Name, variable.Value)
 	return nil
 }
 
@@ -1426,7 +654,7 @@ func runActionsVariableCreate(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to load config: %w", err)
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return fmt.Errorf("failed to create client: %w", err)
 	}
@@ -1445,7 +673,7 @@ func runActionsVariableCreate(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to create variable: %w", err)
 	}
 
-	fmt.Fprintf(ios.Out, "Variable '%s' created successfully\n", variableName)
+	fmt.Printf("Variable '%s' created successfully\n", variableName)
 	return nil
 }
 
@@ -1455,7 +683,7 @@ func runActionsVariableUpdate(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to load config: %w", err)
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return fmt.Errorf("failed to create client: %w", err)
 	}
@@ -1474,7 +702,7 @@ func runActionsVariableUpdate(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to update variable: %w", err)
 	}
 
-	fmt.Fprintf(ios.Out, "Variable '%s' updated successfully\n", variableName)
+	fmt.Printf("Variable '%s' updated successfully\n", variableName)
 	return nil
 }
 
@@ -1484,7 +712,7 @@ func runActionsVariableDelete(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to load config: %w", err)
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return fmt.Errorf("failed to create client: %w", err)
 	}
@@ -1502,6 +730,6 @@ func runActionsVariableDelete(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to delete variable: %w", err)
 	}
 
-	fmt.Fprintf(ios.Out, "Variable '%s' deleted successfully\n", variableName)
+	fmt.Printf("Variable '%s' deleted successfully\n", variableName)
 	return nil
 }
diff --git a/cmd/actions_test.go b/cmd/actions_test.go
deleted file mode 100644
index f7d404e..0000000
--- a/cmd/actions_test.go
+++ /dev/null
@@ -1,122 +0,0 @@
-package cmd
-
-import (
-	"reflect"
-	"testing"
-)
-
-func TestSplitKeyValue(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    string
-		expected []string
-	}{
-		{
-			name:     "valid key=value",
-			input:    "environment=production",
-			expected: []string{"environment", "production"},
-		},
-		{
-			name:     "key with empty value",
-			input:    "key=",
-			expected: []string{"key", ""},
-		},
-		{
-			name:     "value with equals sign",
-			input:    "url=https://example.com?foo=bar",
-			expected: []string{"url", "https://example.com?foo=bar"},
-		},
-		{
-			name:     "no equals sign",
-			input:    "invalid",
-			expected: []string{"invalid"},
-		},
-		{
-			name:     "multiple equals signs",
-			input:    "a=b=c=d",
-			expected: []string{"a", "b=c=d"},
-		},
-		{
-			name:     "empty string",
-			input:    "",
-			expected: []string{""},
-		},
-		{
-			name:     "just equals sign",
-			input:    "=",
-			expected: []string{"", ""},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := splitKeyValue(tt.input)
-			if !reflect.DeepEqual(result, tt.expected) {
-				t.Errorf("splitKeyValue(%q) = %v, want %v", tt.input, result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestFormatStatus(t *testing.T) {
-	tests := []struct {
-		name     string
-		status   string
-		expected string
-	}{
-		{
-			name:     "success status",
-			status:   "success",
-			expected: "✓ success",
-		},
-		{
-			name:     "failure status",
-			status:   "failure",
-			expected: "✗ failure",
-		},
-		{
-			name:     "cancelled status",
-			status:   "cancelled",
-			expected: "- cancelled",
-		},
-		{
-			name:     "skipped status",
-			status:   "skipped",
-			expected: "○ skipped",
-		},
-		{
-			name:     "in_progress status",
-			status:   "in_progress",
-			expected: "● in progress",
-		},
-		{
-			name:     "running status",
-			status:   "running",
-			expected: "● in progress",
-		},
-		{
-			name:     "queued status",
-			status:   "queued",
-			expected: "○ queued",
-		},
-		{
-			name:     "waiting status",
-			status:   "waiting",
-			expected: "○ queued",
-		},
-		{
-			name:     "unknown status",
-			status:   "unknown",
-			expected: "unknown",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := formatStatus(tt.status)
-			if result != tt.expected {
-				t.Errorf("formatStatus(%q) = %q, want %q", tt.status, result, tt.expected)
-			}
-		})
-	}
-}
diff --git a/cmd/aliases.go b/cmd/aliases.go
deleted file mode 100644
index 46f0a24..0000000
--- a/cmd/aliases.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package cmd
-
-// Top-level aliases for "actions run" and "actions workflow" — matches gh
-// CLI's ergonomics so users can type `fj run list` and `fj workflow list`
-// instead of `fj actions run list`.
-//
-// Both trees are built from the same factory functions defined in
-// `cmd/actions.go` (newRunCmd / newWorkflowCmd), which means flags and
-// help text are guaranteed identical between the two paths. Previously
-// this file rebuilt parallel trees by hand and silently drifted (the
-// `--json` Bool/string mismatch was the symptom that surfaced).
-
-func init() {
-	rootCmd.AddCommand(newRunCmd(" (alias for 'actions run')"))
-	rootCmd.AddCommand(newWorkflowCmd(" (alias for 'actions workflow')"))
-}
diff --git a/cmd/api.go b/cmd/api.go
deleted file mode 100644
index 753ff49..0000000
--- a/cmd/api.go
+++ /dev/null
@@ -1,405 +0,0 @@
-package cmd
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"os"
-	"strconv"
-	"strings"
-
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
-	"forgejo.zerova.net/public/fj/internal/git"
-	"github.com/spf13/cobra"
-)
-
-// maxAPIResponseBytes caps response bodies for `fj api`. Forgejo responses
-// are normally <1 MB; 64 MB is enough for any sane payload while preventing
-// a runaway body from OOMing the CLI when combined with the 30 s client
-// timeout.
-const maxAPIResponseBytes = 64 << 20
-
-var apiCmd = &cobra.Command{
-	Use:   "api <endpoint> [flags]",
-	Short: "Make an authenticated API request",
-	Long: `Makes an authenticated HTTP request to the Forgejo API and prints the response.
-
-The endpoint argument should be a path like "/repos/{owner}/{repo}/pulls".
-Placeholders {owner} and {repo} are automatically replaced with values
-detected from the current git repository.
-
-If --field is used and no --method is specified, the method defaults to POST.`,
-	Example: `  # List pull requests for the current repository
-  fj api /repos/{owner}/{repo}/pulls
-
-  # Create an issue
-  fj api /repos/{owner}/{repo}/issues --method POST --field title=Bug --field body="It broke"
-
-  # Get a specific user
-  fj api /users/johndoe
-
-  # Use raw body from stdin
-  echo '{"title":"test"}' | fj api /repos/{owner}/{repo}/issues --input -
-
-  # Filter the response with a jq expression
-  fj api /repos/{owner}/{repo}/issues --jq '.[].title'
-
-  # Project the response down to specific fields
-  fj api /repos/{owner}/{repo} --json-fields full_name,description,private`,
-	Args: cobra.ExactArgs(1),
-	RunE: runAPI,
-}
-
-func init() {
-	rootCmd.AddCommand(apiCmd)
-
-	apiCmd.Flags().StringP("method", "X", "", "HTTP method (default: GET, or POST if --field is used)")
-	apiCmd.Flags().StringArrayP("field", "f", nil, "Add a typed field to the request body (key=value)")
-	apiCmd.Flags().StringArrayP("raw-field", "F", nil, "Add a string field to the request body (key=value)")
-	apiCmd.Flags().String("input", "", "Read request body from file (use \"-\" for stdin)")
-	apiCmd.Flags().StringArrayP("header", "H", nil, "Add an HTTP request header (key:value)")
-	apiCmd.Flags().Bool("silent", false, "Do not print the response body")
-	apiCmd.Flags().BoolP("include", "i", false, "Include HTTP response headers in the output")
-	apiCmd.Flags().Bool("paginate", false, "Follow rel=\"next\" Link headers and concatenate JSON array pages (gh-compatible)")
-	addJSONFlags(apiCmd, "Output the response as JSON")
-}
-
-// parseLinkHeaderNext extracts the URL with rel="next" from an RFC 5988
-// Link header. Returns "" if not present.
-func parseLinkHeaderNext(link string) string {
-	for _, segment := range strings.Split(link, ",") {
-		segment = strings.TrimSpace(segment)
-		if !strings.Contains(segment, `rel="next"`) {
-			continue
-		}
-		start := strings.Index(segment, "<")
-		end := strings.Index(segment, ">")
-		if start >= 0 && end > start {
-			return segment[start+1 : end]
-		}
-	}
-	return ""
-}
-
-// concatPaginatedJSON parses each body as a JSON array and merges them.
-// Errors if any body isn't an array (e.g. an object response means the
-// endpoint isn't paginated and --paginate doesn't apply).
-func concatPaginatedJSON(bodies [][]byte) ([]byte, error) {
-	merged := make([]json.RawMessage, 0)
-	for i, b := range bodies {
-		var page []json.RawMessage
-		if err := json.Unmarshal(b, &page); err != nil {
-			return nil, fmt.Errorf("--paginate requires JSON array responses; page %d wasn't an array: %w", i+1, err)
-		}
-		merged = append(merged, page...)
-	}
-	return json.Marshal(merged)
-}
-
-func runAPI(cmd *cobra.Command, args []string) error {
-	endpoint := args[0]
-
-	method, _ := cmd.Flags().GetString("method")
-	fields, _ := cmd.Flags().GetStringArray("field")
-	rawFields, _ := cmd.Flags().GetStringArray("raw-field")
-	inputFile, _ := cmd.Flags().GetString("input")
-	headers, _ := cmd.Flags().GetStringArray("header")
-	hostname, _ := cmd.Flags().GetString("hostname")
-	silent, _ := cmd.Flags().GetBool("silent")
-	include, _ := cmd.Flags().GetBool("include")
-
-	// Resolve hostname and token from config
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	detectedHost := getDetectedHost()
-
-	host, err := cfg.GetHost(hostname, detectedHost, getCwd())
-	if err != nil {
-		return err
-	}
-
-	// Interpolate {owner} and {repo} placeholders
-	if strings.Contains(endpoint, "{owner}") || strings.Contains(endpoint, "{repo}") {
-		owner, repo, detectErr := git.DetectRepo()
-		if detectErr != nil {
-			return fmt.Errorf("cannot determine repository for path interpolation: %w", detectErr)
-		}
-		endpoint = strings.ReplaceAll(endpoint, "{owner}", owner)
-		endpoint = strings.ReplaceAll(endpoint, "{repo}", repo)
-	}
-
-	// Determine HTTP method
-	hasBody := len(fields) > 0 || len(rawFields) > 0 || inputFile != ""
-	if method == "" {
-		if hasBody {
-			method = http.MethodPost
-		} else {
-			method = http.MethodGet
-		}
-	}
-	method = strings.ToUpper(method)
-
-	// Build request body
-	var body io.Reader
-	if inputFile != "" {
-		if len(fields) > 0 || len(rawFields) > 0 {
-			return fmt.Errorf("--input cannot be combined with --field or --raw-field")
-		}
-		if inputFile == "-" {
-			body = os.Stdin
-		} else {
-			f, openErr := os.Open(inputFile)
-			if openErr != nil {
-				return fmt.Errorf("failed to open input file: %w", openErr)
-			}
-			defer func() { _ = f.Close() }()
-			body = f
-		}
-	} else if len(fields) > 0 || len(rawFields) > 0 {
-		bodyMap := make(map[string]any)
-
-		for _, f := range fields {
-			key, value, parseErr := parseField(f, false)
-			if parseErr != nil {
-				return parseErr
-			}
-			bodyMap[key] = value
-		}
-		for _, f := range rawFields {
-			key, value, parseErr := parseField(f, true)
-			if parseErr != nil {
-				return parseErr
-			}
-			bodyMap[key] = value
-		}
-
-		bodyBytes, marshalErr := json.Marshal(bodyMap)
-		if marshalErr != nil {
-			return fmt.Errorf("failed to marshal request body: %w", marshalErr)
-		}
-		body = bytes.NewReader(bodyBytes)
-	}
-
-	// Build the request URL safely. Naive concatenation lets endpoints like
-	// "/../admin/users" escape the /api/v1 base via Go's URL normalization
-	// of `..` segments — silently sending authenticated traffic to non-API
-	// paths. Parse the endpoint, reject `..`, then JoinPath onto the base.
-	endpointURL, err := url.Parse(endpoint)
-	if err != nil {
-		return fmt.Errorf("invalid endpoint %q: %w", endpoint, err)
-	}
-	if endpointURL.Scheme != "" || endpointURL.Host != "" {
-		return fmt.Errorf("endpoint must be a path, not a full URL: %s", endpoint)
-	}
-	for _, seg := range strings.Split(strings.Trim(endpointURL.Path, "/"), "/") {
-		if seg == ".." {
-			return fmt.Errorf("endpoint contains forbidden '..' segment: %s", endpoint)
-		}
-	}
-	base := &url.URL{Scheme: "https", Host: host.Hostname, Path: "/api/v1"}
-	final := base.JoinPath(endpointURL.Path)
-	final.RawQuery = endpointURL.RawQuery
-
-	// Create HTTP request
-	req, err := http.NewRequest(method, final.String(), body)
-	if err != nil {
-		return fmt.Errorf("failed to create request: %w", err)
-	}
-
-	// Set auth header
-	if host.Token != "" {
-		req.Header.Set("Authorization", "token "+host.Token)
-	}
-	req.Header.Set("Accept", "application/json")
-	if hasBody {
-		req.Header.Set("Content-Type", "application/json")
-	}
-
-	// Apply custom headers
-	for _, h := range headers {
-		key, value, found := strings.Cut(h, ":")
-		if !found {
-			return fmt.Errorf("invalid header format %q (expected key:value)", h)
-		}
-		req.Header.Set(strings.TrimSpace(key), strings.TrimSpace(value))
-	}
-
-	paginate, _ := cmd.Flags().GetBool("paginate")
-	if paginate && method != http.MethodGet {
-		return fmt.Errorf("--paginate only supports GET requests")
-	}
-
-	// doOnce executes a single request via the shared client (30 s timeout,
-	// pooled connections), reads the body bounded by maxAPIResponseBytes,
-	// and closes the body before returning. Previous zero-value http.Client{}
-	// had no timeout, pinning the CLI on a hung Forgejo indefinitely.
-	doOnce := func(r *http.Request) (body []byte, header http.Header, status int, proto string, statusText string, retErr error) {
-		ios.StartSpinner("Requesting...")
-		resp, err := api.SharedHTTPClient.Do(r)
-		ios.StopSpinner()
-		if err != nil {
-			return nil, nil, 0, "", "", fmt.Errorf("failed to perform request: %w", err)
-		}
-		defer func() { _ = resp.Body.Close() }()
-
-		body, err = io.ReadAll(io.LimitReader(resp.Body, maxAPIResponseBytes+1))
-		if err != nil {
-			return nil, nil, 0, "", "", fmt.Errorf("failed to read response body: %w", err)
-		}
-		if int64(len(body)) > maxAPIResponseBytes {
-			return nil, nil, 0, "", "", fmt.Errorf("response body exceeded %d bytes (use a different tool for bulk transfers)", maxAPIResponseBytes)
-		}
-		return body, resp.Header, resp.StatusCode, resp.Proto, resp.Status, nil
-	}
-
-	respBody, respHeader, statusCode, proto, status, err := doOnce(req)
-	if err != nil {
-		return err
-	}
-
-	if include {
-		fmt.Fprintf(ios.Out, "%s %s\n", proto, status)
-		for key, values := range respHeader {
-			for _, v := range values {
-				fmt.Fprintf(ios.Out, "%s: %s\n", key, v)
-			}
-		}
-		fmt.Fprintln(ios.Out)
-	}
-
-	if statusCode < 200 || statusCode >= 300 {
-		if !silent {
-			fmt.Fprint(ios.ErrOut, string(respBody))
-			if len(respBody) > 0 && respBody[len(respBody)-1] != '\n' {
-				fmt.Fprintln(ios.ErrOut)
-			}
-		}
-		return fmt.Errorf("API request failed with status %d", statusCode)
-	}
-
-	// Follow `Link: rel="next"` headers when --paginate is set, accumulating
-	// each page's body. After the loop, concatPaginatedJSON merges them into
-	// a single JSON array. Endpoint must be paginatable (returns an array).
-	if paginate {
-		bodies := [][]byte{respBody}
-		nextURL := parseLinkHeaderNext(respHeader.Get("Link"))
-		for nextURL != "" {
-			// Forgejo emits same-origin next-links in practice, but a buggy
-			// or hostile upstream could redirect us to a foreign host — at
-			// which point we'd leak the bearer token. Validate origin (and
-			// resolve relative URLs against `base`) before forwarding auth.
-			parsedNext, err := url.Parse(nextURL)
-			if err != nil {
-				return fmt.Errorf("invalid Link rel=\"next\" URL %q: %w", nextURL, err)
-			}
-			if !parsedNext.IsAbs() {
-				parsedNext = base.ResolveReference(parsedNext)
-			}
-			if parsedNext.Scheme != "https" || parsedNext.Host != host.Hostname {
-				return fmt.Errorf("paginated next URL %s is not same-origin as https://%s; refusing to forward credentials", parsedNext.String(), host.Hostname)
-			}
-
-			nextReq, err := http.NewRequest(http.MethodGet, parsedNext.String(), nil)
-			if err != nil {
-				return fmt.Errorf("failed to build paginated request: %w", err)
-			}
-			if host.Token != "" {
-				nextReq.Header.Set("Authorization", "token "+host.Token)
-			}
-			nextReq.Header.Set("Accept", "application/json")
-			for _, h := range headers {
-				key, value, found := strings.Cut(h, ":")
-				if !found {
-					continue
-				}
-				nextReq.Header.Set(strings.TrimSpace(key), strings.TrimSpace(value))
-			}
-			pageBody, pageHeader, pageStatus, _, _, err := doOnce(nextReq)
-			if err != nil {
-				return err
-			}
-			if pageStatus < 200 || pageStatus >= 300 {
-				return fmt.Errorf("paginated request to %s failed with status %d", parsedNext.String(), pageStatus)
-			}
-			bodies = append(bodies, pageBody)
-			nextURL = parseLinkHeaderNext(pageHeader.Get("Link"))
-		}
-		merged, err := concatPaginatedJSON(bodies)
-		if err != nil {
-			return err
-		}
-		respBody = merged
-	}
-
-	if silent || len(respBody) == 0 {
-		return nil
-	}
-
-	contentType := respHeader.Get("Content-Type")
-	isJSON := strings.Contains(contentType, "json") || json.Valid(respBody)
-
-	// If the user asked for JSON projection or jq filtering, route through
-	// the shared JSON output helpers so the API command is consistent with
-	// `fj repo list`, `fj pr list`, etc.
-	if wantJSON(cmd) {
-		if !isJSON {
-			return fmt.Errorf("--json/--json-fields/--jq requires a JSON response, but the server returned %s", contentType)
-		}
-		var parsed any
-		if err := json.Unmarshal(respBody, &parsed); err != nil {
-			return fmt.Errorf("response is not valid JSON: %w", err)
-		}
-		return outputJSON(cmd, parsed)
-	}
-
-	// Pretty-print JSON by default, otherwise emit raw bytes.
-	if isJSON {
-		var parsed any
-		if err := json.Unmarshal(respBody, &parsed); err == nil {
-			return writeJSON(parsed)
-		}
-	}
-
-	_, err = ios.Out.Write(respBody)
-	return err
-}
-
-// parseField parses a "key=value" string. When rawString is true, the value is
-// always treated as a string. Otherwise, the function attempts JSON type
-// inference: booleans ("true"/"false"), null, numbers, and falls back to string.
-func parseField(field string, rawString bool) (string, any, error) {
-	key, value, found := strings.Cut(field, "=")
-	if !found {
-		return "", nil, fmt.Errorf("invalid field format %q (expected key=value)", field)
-	}
-
-	if rawString {
-		return key, value, nil
-	}
-
-	// JSON type inference
-	switch {
-	case value == "true":
-		return key, true, nil
-	case value == "false":
-		return key, false, nil
-	case value == "null":
-		return key, nil, nil
-	default:
-		// Try number
-		if n, err := strconv.ParseInt(value, 10, 64); err == nil {
-			return key, n, nil
-		}
-		if f, err := strconv.ParseFloat(value, 64); err == nil {
-			return key, f, nil
-		}
-		return key, value, nil
-	}
-}
diff --git a/cmd/auth.go b/cmd/auth.go
index 53ce982..d52732f 100644
--- a/cmd/auth.go
+++ b/cmd/auth.go
@@ -7,16 +7,15 @@ import (
 	"strings"
 	"syscall"
 
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
 	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
+	"codeberg.org/romaintb/fgj/internal/api"
+	"codeberg.org/romaintb/fgj/internal/config"
 	"golang.org/x/term"
 )
 
 var authCmd = &cobra.Command{
 	Use:   "auth",
-	Short: "Authenticate fj with a Forgejo instance",
+	Short: "Authenticate fgj with a Forgejo instance",
 	Long:  "Manage authentication state for Forgejo instances.",
 }
 
@@ -34,50 +33,23 @@ var authStatusCmd = &cobra.Command{
 	RunE:  runAuthStatus,
 }
 
-var authLogoutCmd = &cobra.Command{
-	Use:   "logout",
-	Short: "Remove authentication for a Forgejo instance",
-	Long:  "Remove authentication for a configured Forgejo instance.",
-	RunE:  runAuthLogout,
-}
-
-var authTokenCmd = &cobra.Command{
-	Use:   "token",
-	Short: "Print the stored authentication token",
-	Long:  "Print the stored authentication token for a configured Forgejo instance.",
-	RunE:  runAuthToken,
-}
-
 func init() {
 	rootCmd.AddCommand(authCmd)
 	authCmd.AddCommand(authLoginCmd)
 	authCmd.AddCommand(authStatusCmd)
-	authCmd.AddCommand(authLogoutCmd)
-	authCmd.AddCommand(authTokenCmd)
 
-	// --hostname is a persistent flag on rootCmd (cmd/root.go). Don't
-	// re-declare it on auth subcommands — local flags shadow the persistent
-	// one, so `fj --hostname=X auth login` and `fj auth login --hostname=X`
-	// went through different code paths (viper vs. local).
-	authLoginCmd.Flags().StringP("token", "t", "", "Personal access token (DEPRECATED: visible in `ps auxe`; pipe via stdin instead)")
+	authLoginCmd.Flags().String("hostname", "", "Forgejo instance hostname (e.g., codeberg.org)")
+	authLoginCmd.Flags().StringP("token", "t", "", "Personal access token")
 }
 
 func runAuthLogin(cmd *cobra.Command, args []string) error {
 	hostname, _ := cmd.Flags().GetString("hostname")
 	token, _ := cmd.Flags().GetString("token")
 
-	// Tokens passed via --token end up on the process command line and
-	// therefore in `ps auxe` and shell history. Warn loudly so users notice.
-	// (Don't refuse the flag — too disruptive for scripts that already use it.)
-	if cmd.Flags().Changed("token") {
-		fmt.Fprintln(ios.ErrOut, "warning: --token puts the token on the command line (visible in `ps auxe` and shell history)")
-		fmt.Fprintln(ios.ErrOut, "         prefer omitting --token and pasting at the prompt, or piping via stdin.")
-	}
-
 	reader := bufio.NewReader(os.Stdin)
 
 	if hostname == "" {
-		fmt.Fprint(ios.ErrOut, "Forgejo instance hostname (default: codeberg.org): ")
+		fmt.Print("Forgejo instance hostname (default: codeberg.org): ")
 		input, _ := reader.ReadString('\n')
 		hostname = strings.TrimSpace(input)
 		if hostname == "" {
@@ -86,12 +58,12 @@ func runAuthLogin(cmd *cobra.Command, args []string) error {
 	}
 
 	if token == "" {
-		fmt.Fprint(ios.ErrOut, "Personal access token: ")
+		fmt.Print("Personal access token: ")
 		tokenBytes, err := term.ReadPassword(int(syscall.Stdin))
 		if err != nil {
 			return fmt.Errorf("failed to read token: %w", err)
 		}
-		fmt.Fprintln(ios.ErrOut)
+		fmt.Println()
 		token = strings.TrimSpace(string(tokenBytes))
 	}
 
@@ -104,9 +76,7 @@ func runAuthLogin(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to create client: %w", err)
 	}
 
-	ios.StartSpinner("Authenticating...")
 	user, _, err := client.GetMyUserInfo()
-	ios.StopSpinner()
 	if err != nil {
 		return fmt.Errorf("authentication failed: %w", err)
 	}
@@ -117,9 +87,9 @@ func runAuthLogin(cmd *cobra.Command, args []string) error {
 	}
 
 	cfg.SetHost(hostname, config.HostConfig{
-		Hostname:    hostname,
-		Token:       token,
-		User:        user.UserName,
+		Hostname: hostname,
+		Token:    token,
+		User:     user.UserName,
 		GitProtocol: "https",
 	})
 
@@ -127,8 +97,7 @@ func runAuthLogin(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to save config: %w", err)
 	}
 
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Authenticated as %s on %s\n", cs.SuccessIcon(), user.UserName, hostname)
+	fmt.Printf("✓ Authenticated as %s on %s\n", user.UserName, hostname)
 
 	return nil
 }
@@ -140,80 +109,15 @@ func runAuthStatus(cmd *cobra.Command, args []string) error {
 	}
 
 	if len(cfg.Hosts) == 0 {
-		fmt.Fprintln(ios.Out, "Not authenticated with any Forgejo instances")
-		fmt.Fprintln(ios.Out, "Run 'fj auth login' to authenticate")
+		fmt.Println("Not authenticated with any Forgejo instances")
+		fmt.Println("Run 'fgj auth login' to authenticate")
 		return nil
 	}
 
-	fmt.Fprintln(ios.Out, "Authenticated instances:")
+	fmt.Println("Authenticated instances:")
 	for hostname, host := range cfg.Hosts {
-		cs := ios.ColorScheme()
-		fmt.Fprintf(ios.Out, "  %s %s (user: %s)\n", cs.SuccessIcon(), hostname, host.User)
+		fmt.Printf("  • %s (user: %s)\n", hostname, host.User)
 	}
 
 	return nil
 }
-
-func runAuthLogout(cmd *cobra.Command, args []string) error {
-	cfg, err := config.Load()
-	if err != nil {
-		return fmt.Errorf("failed to load config: %w", err)
-	}
-
-	hostname, _ := cmd.Flags().GetString("hostname")
-	resolved, err := resolveAuthHostname(cfg, hostname)
-	if err != nil {
-		return err
-	}
-
-	delete(cfg.Hosts, resolved)
-	if err := cfg.Save(); err != nil {
-		return fmt.Errorf("failed to save config: %w", err)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Logged out from %s\n", cs.SuccessIcon(), resolved)
-	return nil
-}
-
-func runAuthToken(cmd *cobra.Command, args []string) error {
-	cfg, err := config.Load()
-	if err != nil {
-		return fmt.Errorf("failed to load config: %w", err)
-	}
-
-	hostname, _ := cmd.Flags().GetString("hostname")
-	resolved, err := resolveAuthHostname(cfg, hostname)
-	if err != nil {
-		return err
-	}
-
-	fmt.Fprintln(ios.Out, cfg.Hosts[resolved].Token)
-	return nil
-}
-
-func resolveAuthHostname(cfg *config.Config, hostname string) (string, error) {
-	if hostname == "" {
-		hostname = viper.GetString("hostname")
-	}
-	if hostname == "" {
-		hostname = config.EnvWithFallback("FJ_HOST", "FGJ_HOST")
-	}
-	if hostname == "" {
-		hostname = getDetectedHost()
-	}
-	if hostname == "" && len(cfg.Hosts) == 1 {
-		for host := range cfg.Hosts {
-			hostname = host
-		}
-	}
-	if hostname == "" {
-		hostname = "codeberg.org"
-	}
-
-	if _, ok := cfg.Hosts[hostname]; !ok {
-		return "", fmt.Errorf("no configuration found for host %s", hostname)
-	}
-
-	return hostname, nil
-}
diff --git a/cmd/completion.go b/cmd/completion.go
deleted file mode 100644
index 6a19f98..0000000
--- a/cmd/completion.go
+++ /dev/null
@@ -1,37 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"io"
-	"os"
-
-	"github.com/spf13/cobra"
-)
-
-var completionCmd = &cobra.Command{
-	Use:                   "completion [bash|zsh|fish|powershell]",
-	Short:                 "Generate shell completion scripts",
-	Long:                  "Generate shell completion scripts for fj.",
-	Args:                  cobra.MatchAll(cobra.ExactArgs(1), cobra.OnlyValidArgs),
-	ValidArgs:             []string{"bash", "zsh", "fish", "powershell"},
-	DisableFlagsInUseLine: true,
-	RunE: func(cmd *cobra.Command, args []string) error {
-		var out io.Writer = os.Stdout
-		switch args[0] {
-		case "bash":
-			return rootCmd.GenBashCompletion(out)
-		case "zsh":
-			return rootCmd.GenZshCompletion(out)
-		case "fish":
-			return rootCmd.GenFishCompletion(out, true)
-		case "powershell":
-			return rootCmd.GenPowerShellCompletionWithDesc(out)
-		default:
-			return fmt.Errorf("unsupported shell: %s", args[0])
-		}
-	},
-}
-
-func init() {
-	rootCmd.AddCommand(completionCmd)
-}
diff --git a/cmd/errors.go b/cmd/errors.go
deleted file mode 100644
index 7617430..0000000
--- a/cmd/errors.go
+++ /dev/null
@@ -1,137 +0,0 @@
-package cmd
-
-import (
-	"encoding/json"
-	"errors"
-	"strings"
-
-	"forgejo.zerova.net/public/fj/internal/api"
-)
-
-// Error codes for structured error output.
-const (
-	ErrAuthRequired       = "auth_required"
-	ErrNotFound           = "not_found"
-	ErrAPIError           = "api_error"
-	ErrInvalidInput       = "invalid_input"
-	ErrGitDetectionFailed = "git_detection_failed"
-	ErrNetworkError       = "network_error"
-)
-
-// CLIError is a structured error type for machine-readable output.
-type CLIError struct {
-	Code    string `json:"code"`
-	Message string `json:"message"`
-	Detail  string `json:"detail,omitempty"`
-	Status  int    `json:"status,omitempty"`
-	// Hint is a separate field so JSON consumers get clean structure and
-	// the human renderer can append "Hint: ..." without polluting Message.
-	Hint string `json:"hint,omitempty"`
-}
-
-func (e *CLIError) Error() string {
-	if e.Hint != "" {
-		return e.Message + "\nHint: " + e.Hint
-	}
-	return e.Message
-}
-
-// NewCLIError creates a new CLIError with the given code and message.
-func NewCLIError(code, message string) *CLIError {
-	return &CLIError{Code: code, Message: message}
-}
-
-// NewAPIError creates a CLIError from an HTTP status and message.
-func NewAPIError(status int, message string) *CLIError {
-	return &CLIError{Code: ErrAPIError, Message: message, Status: status}
-}
-
-// ContextualError wraps common errors with helpful hints.
-//
-// Auth/404 hints come exclusively from a typed *api.APIError now — we used
-// to substring-match "401"/"403" against the rendered error string, which
-// would trigger an "auth login" hint for any error mentioning issue #403.
-// If the API client doesn't surface APIError, no hint is added; that's a
-// signal to fix the client wrapper, not to layer regex on top.
-func ContextualError(err error) error {
-	if err == nil {
-		return nil
-	}
-
-	// If the error chain already holds a CLIError, leave it — it owns its
-	// Code/Hint already.
-	var cErr *CLIError
-	if errors.As(err, &cErr) {
-		return err
-	}
-
-	var apiErr *api.APIError
-	if errors.As(err, &apiErr) {
-		c := &CLIError{
-			Code:    ErrAPIError,
-			Message: err.Error(),
-			Status:  apiErr.StatusCode,
-			Detail:  apiErr.Body,
-		}
-		switch apiErr.StatusCode {
-		case 401, 403:
-			c.Code = ErrAuthRequired
-			c.Hint = "Try authenticating with: fj auth login"
-		case 404:
-			c.Code = ErrNotFound
-			c.Hint = "Resource not found. Check the repository and number are correct."
-		}
-		return c
-	}
-
-	// Plain network errors come back as fmt.Errorf strings from net/http.
-	msg := err.Error()
-	switch {
-	case strings.Contains(msg, "no such host"),
-		strings.Contains(msg, "connection refused"),
-		strings.Contains(msg, "i/o timeout"):
-		return &CLIError{
-			Code:    ErrNetworkError,
-			Message: msg,
-			Hint:    "Check your internet connection and that the host is correct.",
-		}
-	}
-
-	return err
-}
-
-// WriteJSONError writes a structured JSON error to stderr.
-// It is exported for use from main.go.
-func WriteJSONError(err error) {
-	cliErr := &CLIError{
-		Code:    ErrAPIError,
-		Message: err.Error(),
-	}
-
-	// Try to extract structured info from the error chain. Prefer CLIError
-	// (which carries Hint cleanly) over APIError so a wrapped CLIError
-	// keeps its structured fields.
-	var apiErr *api.APIError
-	var cErr *CLIError
-
-	switch {
-	case errors.As(err, &cErr):
-		cliErr = cErr
-	case errors.As(err, &apiErr):
-		cliErr.Status = apiErr.StatusCode
-		cliErr.Detail = apiErr.Body
-		switch {
-		case apiErr.StatusCode == 401 || apiErr.StatusCode == 403:
-			cliErr.Code = ErrAuthRequired
-		case apiErr.StatusCode == 404:
-			cliErr.Code = ErrNotFound
-		}
-	}
-
-	enc := json.NewEncoder(ios.ErrOut)
-	enc.SetIndent("", "  ")
-	_ = enc.Encode(cliErr)
-}
-
-// Compile-time check that CLIError satisfies the standard error interface.
-var _ error = (*CLIError)(nil)
diff --git a/cmd/ios_init.go b/cmd/ios_init.go
deleted file mode 100644
index e4f04c5..0000000
--- a/cmd/ios_init.go
+++ /dev/null
@@ -1,5 +0,0 @@
-package cmd
-
-import "forgejo.zerova.net/public/fj/internal/iostreams"
-
-var ios = iostreams.New()
diff --git a/cmd/issue.go b/cmd/issue.go
index 25f54f3..1644143 100644
--- a/cmd/issue.go
+++ b/cmd/issue.go
@@ -2,14 +2,15 @@ package cmd
 
 import (
 	"fmt"
-	"net/http"
+	"os"
+	"strconv"
 	"strings"
+	"text/tabwriter"
 
 	"code.gitea.io/sdk/gitea"
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
-	"forgejo.zerova.net/public/fj/internal/text"
 	"github.com/spf13/cobra"
+	"codeberg.org/romaintb/fgj/internal/api"
+	"codeberg.org/romaintb/fgj/internal/config"
 )
 
 var issueCmd = &cobra.Command{
@@ -22,114 +23,38 @@ var issueListCmd = &cobra.Command{
 	Use:   "list [flags]",
 	Short: "List issues",
 	Long:  "List issues in a repository.",
-	Example: `  # List open issues
-  fj issue list
-
-  # List closed issues for a specific repo
-  fj issue list -s closed -R owner/repo
-
-  # Output as JSON
-  fj issue list --json`,
-	RunE: runIssueList,
+	RunE:  runIssueList,
 }
 
 var issueViewCmd = &cobra.Command{
 	Use:   "view <number>",
 	Short: "View an issue",
 	Long:  "Display detailed information about an issue.",
-	Example: `  # View issue #42
-  fj issue view 42
-
-  # View using URL
-  fj issue view https://codeberg.org/owner/repo/issues/42
-
-  # Open in browser
-  fj issue view 42 --web
-
-  # View an issue from a specific repo as JSON
-  fj issue view 42 -R owner/repo --json`,
-	Args: cobra.ExactArgs(1),
-	RunE: runIssueView,
+	Args:  cobra.ExactArgs(1),
+	RunE:  runIssueView,
 }
 
 var issueCreateCmd = &cobra.Command{
 	Use:   "create",
 	Short: "Create an issue",
 	Long:  "Create a new issue.",
-	Example: `  # Create an issue with a title
-  fj issue create -t "Fix login bug"
-
-  # Create an issue with title, body, and labels
-  fj issue create -t "Add dark mode" -b "We need a dark theme" -l feature -l ui`,
-	RunE: runIssueCreate,
+	RunE:  runIssueCreate,
 }
 
 var issueCommentCmd = &cobra.Command{
 	Use:   "comment <number>",
 	Short: "Add a comment to an issue",
 	Long:  "Add a comment to an existing issue.",
-	Example: `  # Add a comment to issue #42
-  fj issue comment 42 -b "This is fixed in the latest release"
-
-  # Comment on an issue in a specific repo
-  fj issue comment 10 -b "Confirmed on my end" -R owner/repo`,
-	Args: cobra.ExactArgs(1),
-	RunE: runIssueComment,
+	Args:  cobra.ExactArgs(1),
+	RunE:  runIssueComment,
 }
 
 var issueCloseCmd = &cobra.Command{
 	Use:   "close <number>",
 	Short: "Close an issue",
 	Long:  "Close an existing issue.",
-	Example: `  # Close issue #42
-  fj issue close 42
-
-  # Close with a comment
-  fj issue close 42 -c "Fixed in commit abc1234"`,
-	Args: cobra.ExactArgs(1),
-	RunE: runIssueClose,
-}
-
-var issueReopenCmd = &cobra.Command{
-	Use:   "reopen <number>",
-	Short: "Reopen an issue",
-	Long:  "Reopen a closed issue.",
-	Example: `  # Reopen issue #42
-  fj issue reopen 42`,
-	Args: cobra.ExactArgs(1),
-	RunE: runIssueReopen,
-}
-
-var issueDeleteCmd = &cobra.Command{
-	Use:   "delete <number>",
-	Short: "Delete an issue",
-	Long:  "Delete an issue permanently.",
-	Example: `  # Delete issue #42
-  fj issue delete 42
-
-  # Delete without confirmation
-  fj issue delete 42 -y`,
-	Args: cobra.ExactArgs(1),
-	RunE: runIssueDelete,
-}
-
-var issueEditCmd = &cobra.Command{
-	Use:   "edit <number>",
-	Short: "Edit an issue",
-	Long:  "Edit an existing issue's title, body, or state.",
-	Example: `  # Update the title of issue #42
-  fj issue edit 42 -t "Updated title"
-
-  # Reopen a closed issue
-  fj issue edit 42 -s open
-
-  # Add and remove labels
-  fj issue edit 42 --add-label bug --remove-label wontfix
-
-  # Add a dependency
-  fj issue edit 42 --add-dependency 10`,
-	Args: cobra.ExactArgs(1),
-	RunE: runIssueEdit,
+	Args:  cobra.ExactArgs(1),
+	RunE:  runIssueClose,
 }
 
 func init() {
@@ -139,59 +64,25 @@ func init() {
 	issueCmd.AddCommand(issueCreateCmd)
 	issueCmd.AddCommand(issueCommentCmd)
 	issueCmd.AddCommand(issueCloseCmd)
-	issueCmd.AddCommand(issueReopenCmd)
-	issueCmd.AddCommand(issueDeleteCmd)
-	issueCmd.AddCommand(issueEditCmd)
-
-	issueReopenCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
 
 	issueListCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
 	issueListCmd.Flags().StringP("state", "s", "open", "Filter by state: open, closed, all")
-	issueListCmd.Flags().IntP("limit", "L", 30, "Maximum number of results")
-	issueListCmd.Flags().StringP("assignee", "a", "", "Filter by assignee username")
-	issueListCmd.Flags().String("author", "", "Filter by author username")
-	issueListCmd.Flags().StringSliceP("label", "l", nil, "Filter by label names")
-	issueListCmd.Flags().StringP("search", "S", "", "Search keyword filter")
-	addJSONFlags(issueListCmd, "Output issues as JSON")
 
 	issueViewCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	addJSONFlags(issueViewCmd, "Output issue as JSON")
-	issueViewCmd.Flags().BoolP("web", "w", false, "Open in web browser")
 
 	issueCreateCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
 	issueCreateCmd.Flags().StringP("title", "t", "", "Title for the issue")
 	issueCreateCmd.Flags().StringP("body", "b", "", "Body for the issue")
-	issueCreateCmd.Flags().StringSliceP("label", "l", nil, "Labels to add (can be specified multiple times)")
-	issueCreateCmd.Flags().StringSliceP("assignee", "a", nil, "Assign people by their login. Use \"@me\" to self-assign.")
-	issueCreateCmd.Flags().StringP("milestone", "m", "", "Milestone name to associate with the issue")
 
 	issueCommentCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
 	issueCommentCmd.Flags().StringP("body", "b", "", "Comment body")
 
 	issueCloseCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	issueCloseCmd.Flags().StringP("comment", "c", "", "Comment body to add before closing")
-
-	issueDeleteCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	issueDeleteCmd.Flags().BoolP("yes", "y", false, "Skip confirmation prompt")
-
-	issueEditCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	issueEditCmd.Flags().StringP("title", "t", "", "New title for the issue")
-	issueEditCmd.Flags().StringP("body", "b", "", "New body for the issue")
-	issueEditCmd.Flags().StringP("state", "s", "", "New state for the issue (open or closed)")
-	issueEditCmd.Flags().StringSlice("add-label", nil, "Labels to add (can be specified multiple times)")
-	issueEditCmd.Flags().StringSlice("remove-label", nil, "Labels to remove (can be specified multiple times)")
-	issueEditCmd.Flags().Int64Slice("add-dependency", nil, "Issue numbers to add as dependencies (can be specified multiple times)")
-	issueEditCmd.Flags().Int64Slice("remove-dependency", nil, "Issue numbers to remove as dependencies (can be specified multiple times)")
 }
 
 func runIssueList(cmd *cobra.Command, args []string) error {
 	repo, _ := cmd.Flags().GetString("repo")
 	state, _ := cmd.Flags().GetString("state")
-	limit, _ := cmd.Flags().GetInt("limit")
-	assignee, _ := cmd.Flags().GetString("assignee")
-	author, _ := cmd.Flags().GetString("author")
-	labels, _ := cmd.Flags().GetStringSlice("label")
-	search, _ := cmd.Flags().GetString("search")
 
 	owner, name, err := parseRepo(repo)
 	if err != nil {
@@ -203,7 +94,7 @@ func runIssueList(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return err
 	}
@@ -220,61 +111,33 @@ func runIssueList(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("invalid state: %s", state)
 	}
 
-	ios.StartSpinner("Fetching issues...")
-	// ListRepoIssues returns both issues AND PRs (we filter PRs out below).
-	// Pull more than `limit` so post-filter we still have `limit` real issues
-	// — overshoot 2x as a heuristic. paginateGitea(0, ...) would be safer
-	// but spends extra round-trips; keep it bounded.
-	fetchLimit := limit * 2
-	if fetchLimit < 50 {
-		fetchLimit = 50
-	}
-	issues, err := paginateGitea(fetchLimit, func(page, pageSize int) ([]*gitea.Issue, error) {
-		batch, _, err := client.ListRepoIssues(owner, name, gitea.ListIssueOption{
-			State:       stateType,
-			Labels:      labels,
-			KeyWord:     search,
-			CreatedBy:   author,
-			AssignedBy:  assignee,
-			ListOptions: gitea.ListOptions{Page: page, PageSize: pageSize},
-		})
-		return batch, err
+	issues, _, err := client.ListRepoIssues(owner, name, gitea.ListIssueOption{
+		State: stateType,
 	})
-	ios.StopSpinner()
 	if err != nil {
 		return fmt.Errorf("failed to list issues: %w", err)
 	}
 
-	nonPRIssues := make([]*gitea.Issue, 0, len(issues))
-	for _, issue := range issues {
-		if issue.PullRequest == nil {
-			nonPRIssues = append(nonPRIssues, issue)
-		}
-	}
-	if limit > 0 && len(nonPRIssues) > limit {
-		nonPRIssues = nonPRIssues[:limit]
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, nonPRIssues)
-	}
-
-	if len(nonPRIssues) == 0 {
-		fmt.Fprintf(ios.Out, "No %s issues in %s/%s\n", state, owner, name)
+	if len(issues) == 0 {
+		fmt.Printf("No %s issues in %s/%s\n", state, owner, name)
 		return nil
 	}
 
-	tp := ios.NewTablePrinter()
-	tp.AddHeader("NUMBER", "TITLE", "STATE")
-	for _, issue := range nonPRIssues {
-		tp.AddRow(fmt.Sprintf("#%d", issue.Index), issue.Title, string(issue.State))
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+	_, _ = fmt.Fprintf(w, "NUMBER\tTITLE\tSTATE\n")
+	for _, issue := range issues {
+		if issue.PullRequest == nil {
+			_, _ = fmt.Fprintf(w, "#%d\t%s\t%s\n", issue.Index, issue.Title, issue.State)
+		}
 	}
-	return tp.Render()
+	_ = w.Flush()
+
+	return nil
 }
 
 func runIssueView(cmd *cobra.Command, args []string) error {
 	repo, _ := cmd.Flags().GetString("repo")
-	issueNumber, err := parseIssueArg(args[0])
+	issueNumber, err := strconv.ParseInt(args[0], 10, 64)
 	if err != nil {
 		return fmt.Errorf("invalid issue number: %w", err)
 	}
@@ -289,65 +152,34 @@ func runIssueView(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return err
 	}
 
-	ios.StartSpinner("Fetching issue...")
 	issue, _, err := client.GetIssue(owner, name, issueNumber)
 	if err != nil {
-		ios.StopSpinner()
 		return fmt.Errorf("failed to get issue: %w", err)
 	}
 
-	var comments []*gitea.Comment
-	comments, _, err = client.ListIssueComments(owner, name, issueNumber, gitea.ListIssueCommentOptions{})
-	if err != nil {
-		comments = nil
-	}
-	ios.StopSpinner()
-
-	if web, _ := cmd.Flags().GetBool("web"); web {
-		return ios.OpenInBrowser(issue.HTMLURL)
-	}
-
-	if wantJSON(cmd) {
-		payload := struct {
-			Issue    *gitea.Issue     `json:"issue"`
-			Comments []*gitea.Comment `json:"comments,omitempty"`
-		}{
-			Issue:    issue,
-			Comments: comments,
-		}
-		return outputJSON(cmd, payload)
-	}
-
-	if err := ios.StartPager(); err != nil {
-		fmt.Fprintf(ios.ErrOut, "warning: failed to start pager: %v\n", err)
-	}
-	defer ios.StopPager()
-
-	cs := ios.ColorScheme()
-	isTTY := ios.IsStdoutTTY()
-
-	fmt.Fprintf(ios.Out, "Issue #%d\n", issue.Index)
-	fmt.Fprintf(ios.Out, "Title: %s\n", cs.Bold(issue.Title))
-	fmt.Fprintf(ios.Out, "State: %s\n", issue.State)
-	fmt.Fprintf(ios.Out, "Author: %s\n", issue.Poster.UserName)
-	fmt.Fprintf(ios.Out, "Created: %s\n", text.FormatDate(issue.Created, isTTY))
-	fmt.Fprintf(ios.Out, "Updated: %s\n", text.FormatDate(issue.Updated, isTTY))
+	fmt.Printf("Issue #%d\n", issue.Index)
+	fmt.Printf("Title: %s\n", issue.Title)
+	fmt.Printf("State: %s\n", issue.State)
+	fmt.Printf("Author: %s\n", issue.Poster.UserName)
+	fmt.Printf("Created: %s\n", issue.Created.Format("2006-01-02 15:04:05"))
+	fmt.Printf("Updated: %s\n", issue.Updated.Format("2006-01-02 15:04:05"))
 	if issue.Body != "" {
-		fmt.Fprintf(ios.Out, "\n%s\n", issue.Body)
+		fmt.Printf("\n%s\n", issue.Body)
 	}
 
-	if len(comments) > 0 {
-		fmt.Fprintf(ios.Out, "\nComments (%d):\n", len(comments))
+	comments, _, err := client.ListIssueComments(owner, name, issueNumber, gitea.ListIssueCommentOptions{})
+	if err == nil && len(comments) > 0 {
+		fmt.Printf("\nComments (%d):\n", len(comments))
 		for _, comment := range comments {
-			fmt.Fprintf(ios.Out, "\n---\n%s (@%s) - %s\n%s\n",
+			fmt.Printf("\n---\n%s (@%s) - %s\n%s\n",
 				comment.Poster.FullName,
 				comment.Poster.UserName,
-				text.FormatDate(comment.Created, isTTY),
+				comment.Created.Format("2006-01-02 15:04:05"),
 				comment.Body)
 		}
 	}
@@ -359,29 +191,14 @@ func runIssueCreate(cmd *cobra.Command, args []string) error {
 	repo, _ := cmd.Flags().GetString("repo")
 	title, _ := cmd.Flags().GetString("title")
 	body, _ := cmd.Flags().GetString("body")
-	labelNames, _ := cmd.Flags().GetStringSlice("label")
-	assignees, _ := cmd.Flags().GetStringSlice("assignee")
-	milestoneName, _ := cmd.Flags().GetString("milestone")
 
 	owner, name, err := parseRepo(repo)
 	if err != nil {
 		return err
 	}
 
-	// Interactive mode: prompt for missing fields when TTY
-	if title == "" && ios.IsStdinTTY() {
-		title, err = promptLine("Title: ")
-		if err != nil {
-			return err
-		}
-		if title == "" {
-			return fmt.Errorf("title is required")
-		}
-		if body == "" {
-			body, _ = promptLine("Body (optional): ")
-		}
-	} else if title == "" {
-		return fmt.Errorf("title is required (use -t flag)")
+	if title == "" {
+		return fmt.Errorf("title is required")
 	}
 
 	cfg, err := config.Load()
@@ -389,69 +206,21 @@ func runIssueCreate(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return err
 	}
 
-	var labelIDs []int64
-	if len(labelNames) > 0 {
-		labelIDs, err = resolveLabelIDs(client, owner, name, labelNames)
-		if err != nil {
-			return err
-		}
-	}
-
-	// Resolve @me in assignees
-	resolvedAssignees := make([]string, 0, len(assignees))
-	for _, assignee := range assignees {
-		if assignee == "@me" {
-			user, _, userErr := client.GetMyUserInfo()
-			if userErr != nil {
-				return fmt.Errorf("failed to get current user info: %w", userErr)
-			}
-			resolvedAssignees = append(resolvedAssignees, user.UserName)
-		} else {
-			resolvedAssignees = append(resolvedAssignees, assignee)
-		}
-	}
-
-	// Resolve milestone name to ID
-	var milestoneID int64
-	if milestoneName != "" {
-		milestones, _, msErr := client.ListRepoMilestones(owner, name, gitea.ListMilestoneOption{})
-		if msErr != nil {
-			return fmt.Errorf("failed to list milestones: %w", msErr)
-		}
-		found := false
-		for _, ms := range milestones {
-			if ms.Title == milestoneName {
-				milestoneID = ms.ID
-				found = true
-				break
-			}
-		}
-		if !found {
-			return fmt.Errorf("milestone not found: %s", milestoneName)
-		}
-	}
-
-	ios.StartSpinner("Creating issue...")
 	issue, _, err := client.CreateIssue(owner, name, gitea.CreateIssueOption{
-		Title:     title,
-		Body:      body,
-		Labels:    labelIDs,
-		Assignees: resolvedAssignees,
-		Milestone: milestoneID,
+		Title: title,
+		Body:  body,
 	})
-	ios.StopSpinner()
 	if err != nil {
 		return fmt.Errorf("failed to create issue: %w", err)
 	}
 
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Issue created: #%d\n", cs.SuccessIcon(), issue.Index)
-	fmt.Fprintf(ios.Out, "View at: %s\n", issue.HTMLURL)
+	fmt.Printf("Issue created: #%d\n", issue.Index)
+	fmt.Printf("View at: %s\n", issue.HTMLURL)
 
 	return nil
 }
@@ -459,7 +228,7 @@ func runIssueCreate(cmd *cobra.Command, args []string) error {
 func runIssueComment(cmd *cobra.Command, args []string) error {
 	repo, _ := cmd.Flags().GetString("repo")
 	body, _ := cmd.Flags().GetString("body")
-	issueNumber, err := parseIssueArg(args[0])
+	issueNumber, err := strconv.ParseInt(args[0], 10, 64)
 	if err != nil {
 		return fmt.Errorf("invalid issue number: %w", err)
 	}
@@ -478,31 +247,27 @@ func runIssueComment(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return err
 	}
 
-	ios.StartSpinner("Adding comment...")
 	comment, _, err := client.CreateIssueComment(owner, name, issueNumber, gitea.CreateIssueCommentOption{
 		Body: body,
 	})
-	ios.StopSpinner()
 	if err != nil {
 		return fmt.Errorf("failed to create comment: %w", err)
 	}
 
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Comment added to issue #%d\n", cs.SuccessIcon(), issueNumber)
-	fmt.Fprintf(ios.Out, "View at: %s\n", comment.HTMLURL)
+	fmt.Printf("Comment added to issue #%d\n", issueNumber)
+	fmt.Printf("View at: %s\n", comment.HTMLURL)
 
 	return nil
 }
 
 func runIssueClose(cmd *cobra.Command, args []string) error {
 	repo, _ := cmd.Flags().GetString("repo")
-	commentBody, _ := cmd.Flags().GetString("comment")
-	issueNumber, err := parseIssueArg(args[0])
+	issueNumber, err := strconv.ParseInt(args[0], 10, 64)
 	if err != nil {
 		return fmt.Errorf("invalid issue number: %w", err)
 	}
@@ -517,285 +282,20 @@ func runIssueClose(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return err
 	}
 
-	if commentBody != "" {
-		ios.StartSpinner("Adding comment...")
-		_, _, err = client.CreateIssueComment(owner, name, issueNumber, gitea.CreateIssueCommentOption{
-			Body: commentBody,
-		})
-		ios.StopSpinner()
-		if err != nil {
-			return fmt.Errorf("failed to create comment: %w", err)
-		}
-	}
-
-	ios.StartSpinner("Closing issue...")
 	stateClosed := gitea.StateClosed
 	_, _, err = client.EditIssue(owner, name, issueNumber, gitea.EditIssueOption{
 		State: &stateClosed,
 	})
-	ios.StopSpinner()
 	if err != nil {
 		return fmt.Errorf("failed to close issue: %w", err)
 	}
 
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Issue #%d closed\n", cs.SuccessIcon(), issueNumber)
+	fmt.Printf("Issue #%d closed\n", issueNumber)
 
 	return nil
 }
-
-func runIssueEdit(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	title, _ := cmd.Flags().GetString("title")
-	body, _ := cmd.Flags().GetString("body")
-	stateStr, _ := cmd.Flags().GetString("state")
-	addLabelNames, _ := cmd.Flags().GetStringSlice("add-label")
-	removeLabelNames, _ := cmd.Flags().GetStringSlice("remove-label")
-	addDeps, _ := cmd.Flags().GetInt64Slice("add-dependency")
-	removeDeps, _ := cmd.Flags().GetInt64Slice("remove-dependency")
-
-	issueNumber, err := parseIssueArg(args[0])
-	if err != nil {
-		return fmt.Errorf("invalid issue number: %w", err)
-	}
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	if title == "" && body == "" && stateStr == "" && len(addLabelNames) == 0 && len(removeLabelNames) == 0 && len(addDeps) == 0 && len(removeDeps) == 0 {
-		return fmt.Errorf("at least one of --title, --body, --state, --add-label, --remove-label, --add-dependency, or --remove-dependency must be provided")
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	editOpt := gitea.EditIssueOption{}
-
-	if title != "" {
-		editOpt.Title = title
-	}
-
-	if body != "" {
-		editOpt.Body = &body
-	}
-
-	if stateStr != "" {
-		switch strings.ToLower(stateStr) {
-		case "open":
-			stateOpen := gitea.StateOpen
-			editOpt.State = &stateOpen
-		case "closed":
-			stateClosed := gitea.StateClosed
-			editOpt.State = &stateClosed
-		default:
-			return fmt.Errorf("invalid state: %s (must be 'open' or 'closed')", stateStr)
-		}
-	}
-
-	ios.StartSpinner("Updating issue...")
-
-	if title != "" || body != "" || stateStr != "" {
-		_, _, err = client.EditIssue(owner, name, issueNumber, editOpt)
-		if err != nil {
-			ios.StopSpinner()
-			return fmt.Errorf("failed to edit issue: %w", err)
-		}
-	}
-
-	if len(addLabelNames) > 0 {
-		labelIDs, err := resolveLabelIDs(client, owner, name, addLabelNames)
-		if err != nil {
-			ios.StopSpinner()
-			return err
-		}
-		_, _, err = client.AddIssueLabels(owner, name, issueNumber, gitea.IssueLabelsOption{
-			Labels: labelIDs,
-		})
-		if err != nil {
-			ios.StopSpinner()
-			return fmt.Errorf("failed to add labels: %w", err)
-		}
-	}
-
-	if len(removeLabelNames) > 0 {
-		labelIDs, err := resolveLabelIDs(client, owner, name, removeLabelNames)
-		if err != nil {
-			ios.StopSpinner()
-			return err
-		}
-		for _, labelID := range labelIDs {
-			_, err = client.DeleteIssueLabel(owner, name, issueNumber, labelID)
-			if err != nil {
-				ios.StopSpinner()
-				return fmt.Errorf("failed to remove label %d: %w", labelID, err)
-			}
-		}
-	}
-
-	ios.StopSpinner()
-
-	for _, depNumber := range addDeps {
-		depIssue, _, err := client.GetIssue(owner, name, depNumber)
-		if err != nil {
-			return fmt.Errorf("failed to get issue #%d: %w", depNumber, err)
-		}
-		depBody := map[string]int64{"id": depIssue.ID}
-		path := fmt.Sprintf("/api/v1/repos/%s/%s/issues/%d/dependencies", owner, name, issueNumber)
-		_, err = client.DoJSON(http.MethodPost, path, depBody, nil)
-		if err != nil {
-			return fmt.Errorf("failed to add dependency #%d: %w", depNumber, err)
-		}
-		fmt.Fprintf(ios.Out, "Added dependency: #%d depends on #%d\n", issueNumber, depNumber)
-	}
-
-	for _, depNumber := range removeDeps {
-		depIssue, _, err := client.GetIssue(owner, name, depNumber)
-		if err != nil {
-			return fmt.Errorf("failed to get issue #%d: %w", depNumber, err)
-		}
-		depBody := map[string]int64{"id": depIssue.ID}
-		path := fmt.Sprintf("/api/v1/repos/%s/%s/issues/%d/dependencies", owner, name, issueNumber)
-		_, err = client.DoJSON(http.MethodDelete, path, depBody, nil)
-		if err != nil {
-			return fmt.Errorf("failed to remove dependency #%d: %w", depNumber, err)
-		}
-		fmt.Fprintf(ios.Out, "Removed dependency: #%d no longer depends on #%d\n", issueNumber, depNumber)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Issue #%d updated\n", cs.SuccessIcon(), issueNumber)
-
-	return nil
-}
-
-func runIssueDelete(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	yes, _ := cmd.Flags().GetBool("yes")
-
-	issueNumber, err := parseIssueArg(args[0])
-	if err != nil {
-		return fmt.Errorf("invalid issue number: %w", err)
-	}
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	if !yes {
-		confirmed, confirmErr := ios.ConfirmAction(fmt.Sprintf("Permanently delete issue #%d from %s/%s?", issueNumber, owner, name))
-		if confirmErr != nil {
-			return confirmErr
-		}
-		if !confirmed {
-			fmt.Fprintln(ios.ErrOut, "Aborted")
-			return nil
-		}
-	}
-
-	ios.StartSpinner("Deleting issue...")
-	_, err = client.DeleteIssue(owner, name, issueNumber)
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to delete issue: %w", err)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Issue #%d deleted from %s/%s\n", cs.SuccessIcon(), issueNumber, owner, name)
-	return nil
-}
-
-func runIssueReopen(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	issueNumber, err := parseIssueArg(args[0])
-	if err != nil {
-		return fmt.Errorf("invalid issue number: %w", err)
-	}
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Reopening issue...")
-	stateOpen := gitea.StateOpen
-	_, _, err = client.EditIssue(owner, name, issueNumber, gitea.EditIssueOption{
-		State: &stateOpen,
-	})
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to reopen issue: %w", err)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Issue #%d reopened\n", cs.SuccessIcon(), issueNumber)
-
-	return nil
-}
-
-func resolveLabelIDs(client *api.Client, owner, name string, labelNames []string) ([]int64, error) {
-	if len(labelNames) == 0 {
-		return nil, nil
-	}
-
-	labels, _, err := client.ListRepoLabels(owner, name, gitea.ListLabelsOptions{})
-	if err != nil {
-		return nil, fmt.Errorf("failed to list labels: %w", err)
-	}
-
-	labelNameToID := make(map[string]int64)
-	for _, label := range labels {
-		labelNameToID[label.Name] = label.ID
-	}
-
-	var labelIDs []int64
-	var missingLabels []string
-	for _, labelName := range labelNames {
-		labelID, exists := labelNameToID[labelName]
-		if !exists {
-			missingLabels = append(missingLabels, labelName)
-			continue
-		}
-		labelIDs = append(labelIDs, labelID)
-	}
-
-	if len(missingLabels) > 0 {
-		return nil, fmt.Errorf("labels not found: %s", strings.Join(missingLabels, ", "))
-	}
-
-	return labelIDs, nil
-}
diff --git a/cmd/json.go b/cmd/json.go
deleted file mode 100644
index 70ac0be..0000000
--- a/cmd/json.go
+++ /dev/null
@@ -1,156 +0,0 @@
-package cmd
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-
-	"github.com/itchyny/gojq"
-	"github.com/spf13/cobra"
-)
-
-// addJSONFlags adds --json, --json-fields, and --jq flags to a command.
-//
-// Flag design (BREAKING CHANGE — the previous --json was a string with
-// NoOptDefVal=" " so `--json=fields` projected and `--json` alone meant
-// "everything". That sentinel produced a `--json string[=" "]` in --help
-// and left users guessing about the equals sign). Now:
-//
-//   - --json          : Bool. "Output the response as JSON." (all fields)
-//   - --json-fields … : String. Comma-separated projection.
-//   - --jq …          : String. jq expression filter.
-//
-// --json and --json-fields are mutually exclusive — pick one. --jq composes
-// with either (or neither, in which case it implies "as JSON").
-func addJSONFlags(cmd *cobra.Command, jsonDesc string) {
-	f := cmd.Flags()
-	f.Bool("json", false, jsonDesc)
-	f.String("json-fields", "", "Output as JSON, projecting only these comma-separated fields")
-	f.String("jq", "", "Filter JSON output using a jq expression")
-	cmd.MarkFlagsMutuallyExclusive("json", "json-fields")
-}
-
-// wantJSON returns true if the user requested JSON output via --json,
-// --json-fields, or --jq.
-func wantJSON(cmd *cobra.Command) bool {
-	if b, _ := cmd.Flags().GetBool("json"); b {
-		return true
-	}
-	if f, _ := cmd.Flags().GetString("json-fields"); f != "" {
-		return true
-	}
-	if jq, _ := cmd.Flags().GetString("jq"); jq != "" {
-		return true
-	}
-	return false
-}
-
-// outputJSON writes a value as JSON, respecting --json-fields and --jq.
-// --json (the bool) is the "no projection, no filter" signal handled
-// implicitly: when neither --json-fields nor --jq is set, the whole value
-// is emitted.
-func outputJSON(cmd *cobra.Command, value any) error {
-	fields, _ := cmd.Flags().GetString("json-fields")
-	jqExpr, _ := cmd.Flags().GetString("jq")
-	return writeJSONFiltered(value, fields, jqExpr)
-}
-
-// writeJSON writes a value as pretty-printed JSON to ios.Out.
-func writeJSON(value any) error {
-	enc := json.NewEncoder(ios.Out)
-	enc.SetIndent("", "  ")
-	return enc.Encode(value)
-}
-
-// writeJSONFiltered writes a value as JSON, optionally selecting specific fields
-// and/or applying a jq expression. If fields is empty and jqExpr is empty, it
-// writes the full value.
-func writeJSONFiltered(value any, fields string, jqExpr string) error {
-	// If no filtering, just write the full JSON.
-	if fields == "" && jqExpr == "" {
-		return writeJSON(value)
-	}
-
-	// Convert value to a generic interface via JSON round-trip so we can
-	// manipulate it with maps/slices.
-	raw, err := json.Marshal(value)
-	if err != nil {
-		return fmt.Errorf("marshaling JSON: %w", err)
-	}
-
-	var data any
-	if err := json.Unmarshal(raw, &data); err != nil {
-		return fmt.Errorf("unmarshaling JSON: %w", err)
-	}
-
-	// Apply field selection if specified.
-	if fields != "" {
-		fieldList := strings.Split(fields, ",")
-		for i, f := range fieldList {
-			fieldList[i] = strings.TrimSpace(f)
-		}
-		data = selectFields(data, fieldList)
-	}
-
-	// Apply jq expression if specified.
-	if jqExpr != "" {
-		return applyJQ(data, jqExpr)
-	}
-
-	return writeJSON(data)
-}
-
-// selectFields filters a JSON value to only include the specified fields.
-// Works on both single objects and arrays of objects.
-func selectFields(data any, fields []string) any {
-	switch v := data.(type) {
-	case []any:
-		result := make([]any, len(v))
-		for i, item := range v {
-			result[i] = selectFields(item, fields)
-		}
-		return result
-	case map[string]any:
-		result := make(map[string]any)
-		for _, field := range fields {
-			if val, ok := v[field]; ok {
-				result[field] = val
-			}
-		}
-		return result
-	default:
-		return data
-	}
-}
-
-// applyJQ applies a jq expression to data and writes each output value.
-func applyJQ(data any, expr string) error {
-	query, err := gojq.Parse(expr)
-	if err != nil {
-		return fmt.Errorf("invalid jq expression: %w", err)
-	}
-
-	iter := query.Run(data)
-	enc := json.NewEncoder(ios.Out)
-	enc.SetIndent("", "  ")
-
-	for {
-		v, ok := iter.Next()
-		if !ok {
-			break
-		}
-		if err, isErr := v.(error); isErr {
-			return fmt.Errorf("jq error: %w", err)
-		}
-		// For string values, print raw (no JSON encoding) to match jq behavior.
-		if s, ok := v.(string); ok {
-			fmt.Fprintln(ios.Out, s)
-		} else {
-			if err := enc.Encode(v); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
diff --git a/cmd/label.go b/cmd/label.go
deleted file mode 100644
index 96cb632..0000000
--- a/cmd/label.go
+++ /dev/null
@@ -1,294 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"strings"
-
-	"code.gitea.io/sdk/gitea"
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
-	"github.com/spf13/cobra"
-)
-
-var labelCmd = &cobra.Command{
-	Use:   "label",
-	Short: "Manage labels",
-	Long:  "List, create, edit, and delete repository labels.",
-}
-
-var labelListCmd = &cobra.Command{
-	Use:   "list",
-	Short: "List labels for a repository",
-	Long:  "List all labels defined in a repository.",
-	Example: `  # List labels for the current repository
-  fj label list
-
-  # List labels for a specific repository
-  fj label list -R owner/repo
-
-  # Output as JSON
-  fj label list --json`,
-	RunE: runLabelList,
-}
-
-var labelCreateCmd = &cobra.Command{
-	Use:   "create <name>",
-	Short: "Create a label",
-	Long:  "Create a new label in a repository.",
-	Example: `  # Create a label with a color
-  fj label create bug -c ff0000
-
-  # Create a label with color and description
-  fj label create feature -c 00ff00 -d "New feature request"
-
-  # Create a label in a specific repository
-  fj label create urgent -c ff0000 -R owner/repo`,
-	Args: cobra.ExactArgs(1),
-	RunE: runLabelCreate,
-}
-
-var labelEditCmd = &cobra.Command{
-	Use:   "edit <name>",
-	Short: "Edit a label",
-	Long:  "Edit an existing label in a repository.",
-	Example: `  # Rename a label
-  fj label edit bug --name bugfix
-
-  # Change the color of a label
-  fj label edit bug -c 00ff00
-
-  # Update description
-  fj label edit bug -d "Something is broken"`,
-	Args: cobra.ExactArgs(1),
-	RunE: runLabelEdit,
-}
-
-var labelDeleteCmd = &cobra.Command{
-	Use:   "delete <name>",
-	Short: "Delete a label",
-	Long:  "Delete a label from a repository.",
-	Example: `  # Delete a label
-  fj label delete bug
-
-  # Delete without confirmation
-  fj label delete bug -y
-
-  # Delete a label from a specific repository
-  fj label delete bug -R owner/repo`,
-	Args: cobra.ExactArgs(1),
-	RunE: runLabelDelete,
-}
-
-func init() {
-	rootCmd.AddCommand(labelCmd)
-	labelCmd.AddCommand(labelListCmd)
-	labelCmd.AddCommand(labelCreateCmd)
-	labelCmd.AddCommand(labelEditCmd)
-	labelCmd.AddCommand(labelDeleteCmd)
-
-	labelListCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	addJSONFlags(labelListCmd, "Output as JSON")
-
-	labelCreateCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	labelCreateCmd.Flags().StringP("color", "c", "", "Label color (hex, e.g. 00ff00)")
-	labelCreateCmd.Flags().StringP("description", "d", "", "Label description")
-	addJSONFlags(labelCreateCmd, "Output as JSON")
-
-	labelEditCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	labelEditCmd.Flags().String("name", "", "New name for the label")
-	labelEditCmd.Flags().StringP("color", "c", "", "New color (hex, e.g. 00ff00)")
-	labelEditCmd.Flags().StringP("description", "d", "", "New description")
-	addJSONFlags(labelEditCmd, "Output as JSON")
-
-	labelDeleteCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	labelDeleteCmd.Flags().BoolP("yes", "y", false, "Skip confirmation prompt")
-}
-
-func newLabelClient(cmd *cobra.Command) (*api.Client, string, string, error) {
-	repo, _ := cmd.Flags().GetString("repo")
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return nil, "", "", err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return nil, "", "", err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return nil, "", "", err
-	}
-
-	return client, owner, name, nil
-}
-
-// findLabelByName lists all repo labels and returns the one matching the given name.
-func findLabelByName(client *api.Client, owner, repo, labelName string) (*gitea.Label, error) {
-	labels, _, err := client.ListRepoLabels(owner, repo, gitea.ListLabelsOptions{})
-	if err != nil {
-		return nil, fmt.Errorf("failed to list labels: %w", err)
-	}
-
-	for _, l := range labels {
-		if strings.EqualFold(l.Name, labelName) {
-			return l, nil
-		}
-	}
-
-	return nil, fmt.Errorf("label not found: %s", labelName)
-}
-
-func runLabelList(cmd *cobra.Command, args []string) error {
-	client, owner, name, err := newLabelClient(cmd)
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Fetching labels...")
-	labels, _, err := client.ListRepoLabels(owner, name, gitea.ListLabelsOptions{})
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to list labels: %w", err)
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, labels)
-	}
-
-	if len(labels) == 0 {
-		fmt.Fprintln(ios.Out, "No labels found")
-		return nil
-	}
-
-	tp := ios.NewTablePrinter()
-	tp.AddHeader("NAME", "COLOR", "DESCRIPTION")
-	for _, l := range labels {
-		tp.AddRow(l.Name, l.Color, l.Description)
-	}
-	return tp.Render()
-}
-
-func runLabelCreate(cmd *cobra.Command, args []string) error {
-	labelName := args[0]
-	color, _ := cmd.Flags().GetString("color")
-	description, _ := cmd.Flags().GetString("description")
-
-	client, owner, name, err := newLabelClient(cmd)
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Creating label...")
-	label, _, err := client.CreateLabel(owner, name, gitea.CreateLabelOption{
-		Name:        labelName,
-		Color:       color,
-		Description: description,
-	})
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to create label: %w", err)
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, label)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Label created: %s\n", cs.SuccessIcon(), label.Name)
-	return nil
-}
-
-func runLabelEdit(cmd *cobra.Command, args []string) error {
-	labelName := args[0]
-
-	client, owner, name, err := newLabelClient(cmd)
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Fetching label...")
-	existing, err := findLabelByName(client, owner, name, labelName)
-	ios.StopSpinner()
-	if err != nil {
-		return err
-	}
-
-	opt := gitea.EditLabelOption{}
-	changed := false
-
-	if cmd.Flags().Changed("name") {
-		n, _ := cmd.Flags().GetString("name")
-		opt.Name = &n
-		changed = true
-	}
-	if cmd.Flags().Changed("color") {
-		c, _ := cmd.Flags().GetString("color")
-		opt.Color = &c
-		changed = true
-	}
-	if cmd.Flags().Changed("description") {
-		d, _ := cmd.Flags().GetString("description")
-		opt.Description = &d
-		changed = true
-	}
-
-	if !changed {
-		return fmt.Errorf("no changes specified; use flags like --name, --color, or --description")
-	}
-
-	ios.StartSpinner("Updating label...")
-	label, _, err := client.EditLabel(owner, name, existing.ID, opt)
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to edit label: %w", err)
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, label)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Label updated: %s\n", cs.SuccessIcon(), label.Name)
-	return nil
-}
-
-func runLabelDelete(cmd *cobra.Command, args []string) error {
-	labelName := args[0]
-	yes, _ := cmd.Flags().GetBool("yes")
-
-	client, owner, name, err := newLabelClient(cmd)
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Fetching label...")
-	existing, err := findLabelByName(client, owner, name, labelName)
-	ios.StopSpinner()
-	if err != nil {
-		return err
-	}
-
-	if !yes {
-		confirmed, err := ios.ConfirmAction(fmt.Sprintf("Delete label %q?", labelName))
-		if err != nil {
-			return err
-		}
-		if !confirmed {
-			fmt.Fprintln(ios.ErrOut, "Aborted")
-			return nil
-		}
-	}
-
-	ios.StartSpinner("Deleting label...")
-	_, err = client.DeleteLabel(owner, name, existing.ID)
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to delete label: %w", err)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Label deleted: %s\n", cs.SuccessIcon(), labelName)
-	return nil
-}
diff --git a/cmd/manpages.go b/cmd/manpages.go
deleted file mode 100644
index b1124f1..0000000
--- a/cmd/manpages.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/spf13/cobra"
-	"github.com/spf13/cobra/doc"
-)
-
-var manpagesCmd = &cobra.Command{
-	Use:   "manpages",
-	Short: "Generate manpages",
-	Long:  "Generate manpages for fj commands.",
-	RunE: func(cmd *cobra.Command, args []string) error {
-		dir, _ := cmd.Flags().GetString("dir")
-		if dir == "" {
-			return fmt.Errorf("directory is required")
-		}
-
-		if err := os.MkdirAll(dir, 0755); err != nil {
-			return fmt.Errorf("failed to create %s: %w", dir, err)
-		}
-
-		absDir, err := filepath.Abs(dir)
-		if err != nil {
-			return fmt.Errorf("failed to resolve %s: %w", dir, err)
-		}
-
-		header := &doc.GenManHeader{
-			Title:   "FJ",
-			Section: "1",
-		}
-
-		if err := doc.GenManTree(rootCmd, header, absDir); err != nil {
-			return fmt.Errorf("failed to generate manpages: %w", err)
-		}
-
-		fmt.Printf("Manpages generated in %s\n", absDir)
-		return nil
-	},
-}
-
-func init() {
-	rootCmd.AddCommand(manpagesCmd)
-	manpagesCmd.Flags().String("dir", "", "Output directory for manpages")
-	_ = manpagesCmd.MarkFlagRequired("dir")
-}
diff --git a/cmd/milestone.go b/cmd/milestone.go
deleted file mode 100644
index a10e6a0..0000000
--- a/cmd/milestone.go
+++ /dev/null
@@ -1,487 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"time"
-
-	"code.gitea.io/sdk/gitea"
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
-	"forgejo.zerova.net/public/fj/internal/text"
-	"github.com/spf13/cobra"
-)
-
-var milestoneCmd = &cobra.Command{
-	Use:   "milestone",
-	Short: "Manage milestones",
-	Long:  "Create, view, list, edit, and delete milestones.",
-}
-
-var milestoneListCmd = &cobra.Command{
-	Use:   "list [flags]",
-	Short: "List milestones",
-	Long:  "List milestones in a repository.",
-	Example: `  # List open milestones
-  fj milestone list
-
-  # List all milestones for a specific repo
-  fj milestone list -R owner/repo --state all
-
-  # Output as JSON
-  fj milestone list --json`,
-	RunE: runMilestoneList,
-}
-
-var milestoneViewCmd = &cobra.Command{
-	Use:   "view <title-or-id>",
-	Short: "View a milestone",
-	Long:  "Display detailed information about a milestone.",
-	Example: `  # View by ID
-  fj milestone view 1
-
-  # View by title
-  fj milestone view "v1.0"
-
-  # Open in browser
-  fj milestone view "v1.0" --web
-
-  # Output as JSON
-  fj milestone view "v1.0" --json`,
-	Args: cobra.ExactArgs(1),
-	RunE: runMilestoneView,
-}
-
-var milestoneCreateCmd = &cobra.Command{
-	Use:   "create <title>",
-	Short: "Create a milestone",
-	Long:  "Create a new milestone.",
-	Example: `  # Create a simple milestone
-  fj milestone create "v1.0"
-
-  # Create with description and due date
-  fj milestone create "v2.0" -d "Second release" --due 2026-06-01
-
-  # Output as JSON
-  fj milestone create "v1.0" --json`,
-	Args: cobra.ExactArgs(1),
-	RunE: runMilestoneCreate,
-}
-
-var milestoneEditCmd = &cobra.Command{
-	Use:   "edit <title-or-id>",
-	Short: "Edit a milestone",
-	Long:  "Edit an existing milestone's title, description, due date, or state.",
-	Example: `  # Rename a milestone
-  fj milestone edit "v1.0" --title "v1.1"
-
-  # Close a milestone
-  fj milestone edit "v1.0" --state closed
-
-  # Update due date
-  fj milestone edit 1 --due 2026-12-31`,
-	Args: cobra.ExactArgs(1),
-	RunE: runMilestoneEdit,
-}
-
-var milestoneDeleteCmd = &cobra.Command{
-	Use:   "delete <title-or-id>",
-	Short: "Delete a milestone",
-	Long:  "Delete an existing milestone.",
-	Example: `  # Delete by title
-  fj milestone delete "v1.0"
-
-  # Delete by ID
-  fj milestone delete 1
-
-  # Delete without confirmation
-  fj milestone delete "v1.0" -y`,
-	Args: cobra.ExactArgs(1),
-	RunE: runMilestoneDelete,
-}
-
-func init() {
-	rootCmd.AddCommand(milestoneCmd)
-	milestoneCmd.AddCommand(milestoneListCmd)
-	milestoneCmd.AddCommand(milestoneViewCmd)
-	milestoneCmd.AddCommand(milestoneCreateCmd)
-	milestoneCmd.AddCommand(milestoneEditCmd)
-	milestoneCmd.AddCommand(milestoneDeleteCmd)
-
-	milestoneListCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	milestoneListCmd.Flags().String("state", "open", "Filter by state: open, closed, all")
-	addJSONFlags(milestoneListCmd, "Output milestones as JSON")
-
-	milestoneViewCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	addJSONFlags(milestoneViewCmd, "Output milestone as JSON")
-	milestoneViewCmd.Flags().BoolP("web", "w", false, "Open in web browser")
-
-	milestoneCreateCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	milestoneCreateCmd.Flags().StringP("description", "d", "", "Description of the milestone")
-	milestoneCreateCmd.Flags().String("due", "", "Due date in YYYY-MM-DD format")
-	addJSONFlags(milestoneCreateCmd, "Output created milestone as JSON")
-
-	milestoneEditCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	milestoneEditCmd.Flags().String("title", "", "New title for the milestone")
-	milestoneEditCmd.Flags().StringP("description", "d", "", "New description for the milestone")
-	milestoneEditCmd.Flags().String("due", "", "Due date in YYYY-MM-DD format")
-	milestoneEditCmd.Flags().String("state", "", "New state: open or closed")
-	addJSONFlags(milestoneEditCmd, "Output updated milestone as JSON")
-
-	milestoneDeleteCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	milestoneDeleteCmd.Flags().BoolP("yes", "y", false, "Skip confirmation prompt")
-}
-
-// resolveMilestone resolves a title-or-id argument to a milestone.
-// If the argument is numeric, it fetches by ID. Otherwise, it lists
-// milestones and finds a match by title.
-func resolveMilestone(client *api.Client, owner, name, arg string) (*gitea.Milestone, error) {
-	if id, err := strconv.ParseInt(arg, 10, 64); err == nil {
-		ms, _, err := client.GetMilestone(owner, name, id)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get milestone %d: %w", id, err)
-		}
-		return ms, nil
-	}
-
-	milestones, _, err := client.ListRepoMilestones(owner, name, gitea.ListMilestoneOption{
-		State: gitea.StateAll,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("failed to list milestones: %w", err)
-	}
-
-	for _, ms := range milestones {
-		if strings.EqualFold(ms.Title, arg) {
-			return ms, nil
-		}
-	}
-
-	return nil, fmt.Errorf("milestone not found: %s", arg)
-}
-
-func parseDueDate(dateStr string) (*time.Time, error) {
-	t, err := time.Parse("2006-01-02", dateStr)
-	if err != nil {
-		return nil, fmt.Errorf("invalid due date %q: expected YYYY-MM-DD format", dateStr)
-	}
-	return &t, nil
-}
-
-func runMilestoneList(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	state, _ := cmd.Flags().GetString("state")
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	var stateType gitea.StateType
-	switch strings.ToLower(state) {
-	case "open":
-		stateType = gitea.StateOpen
-	case "closed":
-		stateType = gitea.StateClosed
-	case "all":
-		stateType = gitea.StateAll
-	default:
-		return fmt.Errorf("invalid state: %s", state)
-	}
-
-	ios.StartSpinner("Fetching milestones...")
-	milestones, _, err := client.ListRepoMilestones(owner, name, gitea.ListMilestoneOption{
-		State: stateType,
-	})
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to list milestones: %w", err)
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, milestones)
-	}
-
-	if len(milestones) == 0 {
-		fmt.Fprintf(ios.Out, "No %s milestones in %s/%s\n", state, owner, name)
-		return nil
-	}
-
-	tp := ios.NewTablePrinter()
-	tp.AddHeader("ID", "TITLE", "STATE", "DUE DATE", "OPEN/CLOSED ISSUES")
-	for _, ms := range milestones {
-		due := ""
-		if ms.Deadline != nil {
-			due = ms.Deadline.Format("2006-01-02")
-		}
-		tp.AddRow(
-			fmt.Sprintf("%d", ms.ID),
-			ms.Title,
-			string(ms.State),
-			due,
-			fmt.Sprintf("%d/%d", ms.OpenIssues, ms.ClosedIssues),
-		)
-	}
-	return tp.Render()
-}
-
-func runMilestoneView(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Fetching milestone...")
-	ms, err := resolveMilestone(client, owner, name, args[0])
-	ios.StopSpinner()
-	if err != nil {
-		return err
-	}
-
-	if web, _ := cmd.Flags().GetBool("web"); web {
-		// Milestones don't have HTMLURL in the API, construct it
-		cfg2, _ := config.Load()
-		host, _ := cfg2.GetHost("", getDetectedHost(), getCwd())
-		url := fmt.Sprintf("https://%s/%s/%s/milestone/%d", host.Hostname, owner, name, ms.ID)
-		return ios.OpenInBrowser(url)
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, ms)
-	}
-
-	cs := ios.ColorScheme()
-	isTTY := ios.IsStdoutTTY()
-
-	fmt.Fprintf(ios.Out, "ID: %d\n", ms.ID)
-	fmt.Fprintf(ios.Out, "Title: %s\n", cs.Bold(ms.Title))
-	fmt.Fprintf(ios.Out, "State: %s\n", ms.State)
-	if ms.Description != "" {
-		fmt.Fprintf(ios.Out, "Description: %s\n", ms.Description)
-	}
-	if ms.Deadline != nil {
-		fmt.Fprintf(ios.Out, "Due Date: %s\n", ms.Deadline.Format("2006-01-02"))
-	}
-	fmt.Fprintf(ios.Out, "Open Issues: %d\n", ms.OpenIssues)
-	fmt.Fprintf(ios.Out, "Closed Issues: %d\n", ms.ClosedIssues)
-	fmt.Fprintf(ios.Out, "Created: %s\n", text.FormatDate(ms.Created, isTTY))
-	if ms.Updated != nil {
-		fmt.Fprintf(ios.Out, "Updated: %s\n", text.FormatDate(*ms.Updated, isTTY))
-	}
-	if ms.Closed != nil {
-		fmt.Fprintf(ios.Out, "Closed: %s\n", text.FormatDate(*ms.Closed, isTTY))
-	}
-
-	return nil
-}
-
-func runMilestoneCreate(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	description, _ := cmd.Flags().GetString("description")
-	dueStr, _ := cmd.Flags().GetString("due")
-
-	title := args[0]
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	opt := gitea.CreateMilestoneOption{
-		Title:       title,
-		Description: description,
-	}
-
-	if dueStr != "" {
-		deadline, err := parseDueDate(dueStr)
-		if err != nil {
-			return err
-		}
-		opt.Deadline = deadline
-	}
-
-	ios.StartSpinner("Creating milestone...")
-	ms, _, err := client.CreateMilestone(owner, name, opt)
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to create milestone: %w", err)
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, ms)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Milestone created: %s\n", cs.SuccessIcon(), ms.Title)
-
-	return nil
-}
-
-func runMilestoneEdit(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Fetching milestone...")
-	ms, err := resolveMilestone(client, owner, name, args[0])
-	ios.StopSpinner()
-	if err != nil {
-		return err
-	}
-
-	opt := gitea.EditMilestoneOption{}
-	changed := false
-
-	if cmd.Flags().Changed("title") {
-		t, _ := cmd.Flags().GetString("title")
-		opt.Title = t
-		changed = true
-	}
-
-	if cmd.Flags().Changed("description") {
-		d, _ := cmd.Flags().GetString("description")
-		opt.Description = &d
-		changed = true
-	}
-
-	if cmd.Flags().Changed("due") {
-		dueStr, _ := cmd.Flags().GetString("due")
-		deadline, err := parseDueDate(dueStr)
-		if err != nil {
-			return err
-		}
-		opt.Deadline = deadline
-		changed = true
-	}
-
-	if cmd.Flags().Changed("state") {
-		stateStr, _ := cmd.Flags().GetString("state")
-		switch strings.ToLower(stateStr) {
-		case "open":
-			s := gitea.StateOpen
-			opt.State = &s
-		case "closed":
-			s := gitea.StateClosed
-			opt.State = &s
-		default:
-			return fmt.Errorf("invalid state: %s (must be 'open' or 'closed')", stateStr)
-		}
-		changed = true
-	}
-
-	if !changed {
-		return fmt.Errorf("no changes specified; use flags like --title, --description, --due, or --state")
-	}
-
-	ios.StartSpinner("Updating milestone...")
-	updated, _, err := client.EditMilestone(owner, name, ms.ID, opt)
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to edit milestone: %w", err)
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, updated)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Milestone updated: %s\n", cs.SuccessIcon(), updated.Title)
-
-	return nil
-}
-
-func runMilestoneDelete(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	yes, _ := cmd.Flags().GetBool("yes")
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Fetching milestone...")
-	ms, err := resolveMilestone(client, owner, name, args[0])
-	ios.StopSpinner()
-	if err != nil {
-		return err
-	}
-
-	if !yes {
-		confirmed, err := ios.ConfirmAction(fmt.Sprintf("Delete milestone %q?", ms.Title))
-		if err != nil {
-			return err
-		}
-		if !confirmed {
-			fmt.Fprintln(ios.ErrOut, "Aborted")
-			return nil
-		}
-	}
-
-	ios.StartSpinner("Deleting milestone...")
-	_, err = client.DeleteMilestone(owner, name, ms.ID)
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to delete milestone: %w", err)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Milestone deleted: %s\n", cs.SuccessIcon(), ms.Title)
-
-	return nil
-}
diff --git a/cmd/paginate.go b/cmd/paginate.go
deleted file mode 100644
index 8c9737e..0000000
--- a/cmd/paginate.go
+++ /dev/null
@@ -1,43 +0,0 @@
-package cmd
-
-// paginateGitea walks pages of a gitea SDK list method until the response
-// is short (last page) or we hit limit. limit=0 means unlimited.
-//
-// Forgejo/Gitea caps PageSize at 50, so naive `PageSize: limit` for limit > 50
-// silently truncated results across most `fj * list` commands. This helper
-// centralizes the loop so every list command paginates consistently.
-//
-// fetch is called with (page, pageSize) and returns the items for that page.
-// The 1-based `page` matches the gitea SDK convention.
-func paginateGitea[T any](limit int, fetch func(page, pageSize int) ([]T, error)) ([]T, error) {
-	const maxPageSize = 50
-	pageSize := maxPageSize
-	if limit > 0 && limit < pageSize {
-		pageSize = limit
-	}
-
-	var all []T
-	for page := 1; ; page++ {
-		if limit > 0 && len(all) >= limit {
-			break
-		}
-		batch, err := fetch(page, pageSize)
-		if err != nil {
-			return all, err
-		}
-		if len(batch) == 0 {
-			break
-		}
-		all = append(all, batch...)
-		// A short page (less than the requested size) is the conventional
-		// "you've reached the end" signal — saves one extra round-trip.
-		if len(batch) < pageSize {
-			break
-		}
-	}
-
-	if limit > 0 && len(all) > limit {
-		all = all[:limit]
-	}
-	return all, nil
-}
diff --git a/cmd/pr.go b/cmd/pr.go
index e38faac..e6d75b2 100644
--- a/cmd/pr.go
+++ b/cmd/pr.go
@@ -2,16 +2,16 @@ package cmd
 
 import (
 	"fmt"
-	"net/http"
-	"os/exec"
+	"os"
+	"strconv"
 	"strings"
+	"text/tabwriter"
 
 	"code.gitea.io/sdk/gitea"
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
-	gitpkg "forgejo.zerova.net/public/fj/internal/git"
-	"forgejo.zerova.net/public/fj/internal/text"
 	"github.com/spf13/cobra"
+	"codeberg.org/romaintb/fgj/internal/api"
+	"codeberg.org/romaintb/fgj/internal/config"
+	"codeberg.org/romaintb/fgj/internal/git"
 )
 
 var prCmd = &cobra.Command{
@@ -25,120 +25,30 @@ var prListCmd = &cobra.Command{
 	Use:   "list [flags]",
 	Short: "List pull requests",
 	Long:  "List pull requests in a repository.",
-	Example: `  # List open pull requests
-  fj pr list
-
-  # List all pull requests for a specific repo
-  fj pr list -s all -R owner/repo
-
-  # Output as JSON
-  fj pr list --json`,
-	RunE: runPRList,
+	RunE:  runPRList,
 }
 
 var prViewCmd = &cobra.Command{
-	Use:   "view [<number>]",
+	Use:   "view <number>",
 	Short: "View a pull request",
 	Long:  "Display detailed information about a pull request.",
-	Example: `  # View pull request #5
-  fj pr view 5
-
-  # View using URL
-  fj pr view https://codeberg.org/owner/repo/pulls/5
-
-  # View PR for current branch
-  fj pr view
-
-  # Open in browser
-  fj pr view 5 --web
-
-  # View as JSON
-  fj pr view 5 --json`,
-	Args: cobra.MaximumNArgs(1),
-	RunE: runPRView,
+	Args:  cobra.ExactArgs(1),
+	RunE:  runPRView,
 }
 
 var prCreateCmd = &cobra.Command{
 	Use:   "create",
 	Short: "Create a pull request",
 	Long:  "Create a new pull request.",
-	Example: `  # Create a pull request from feature branch to main
-  fj pr create -t "Add login page" -H feature/login
-
-  # Create with body and custom base branch
-  fj pr create -t "Fix bug" -b "Closes #42" -H fix/bug -B develop
-
-  # Create and self-assign
-  fj pr create -t "Update docs" -H docs/update -a @me`,
-	RunE: runPRCreate,
+	RunE:  runPRCreate,
 }
 
 var prMergeCmd = &cobra.Command{
 	Use:   "merge <number>",
 	Short: "Merge a pull request",
 	Long:  "Merge a pull request.",
-	Example: `  # Merge pull request #5
-  fj pr merge 5
-
-  # Squash merge
-  fj pr merge 5 --merge-method squash
-
-  # Rebase merge
-  fj pr merge 5 --merge-method rebase
-
-  # Merge without confirmation
-  fj pr merge 5 -y`,
-	Args: cobra.ExactArgs(1),
-	RunE: runPRMerge,
-}
-
-var prCloseCmd = &cobra.Command{
-	Use:   "close <number>",
-	Short: "Close a pull request",
-	Long:  "Close a pull request without merging.",
-	Example: `  # Close PR #5
-  fj pr close 5
-
-  # Close with a comment
-  fj pr close 5 -c "Won't merge, superseded by #10"`,
-	Args: cobra.ExactArgs(1),
-	RunE: runPRClose,
-}
-
-var prReopenCmd = &cobra.Command{
-	Use:   "reopen <number>",
-	Short: "Reopen a pull request",
-	Long:  "Reopen a closed pull request.",
-	Example: `  # Reopen PR #5
-  fj pr reopen 5`,
-	Args: cobra.ExactArgs(1),
-	RunE: runPRReopen,
-}
-
-var prEditCmd = &cobra.Command{
-	Use:   "edit <number>",
-	Short: "Edit a pull request",
-	Long:  "Edit a pull request's title, body, or metadata.",
-	Example: `  # Update the title of PR #5
-  fj pr edit 5 -t "Updated title"
-
-  # Add assignees and labels
-  fj pr edit 5 --add-assignee user1 --add-label bug
-
-  # Remove a reviewer and set milestone
-  fj pr edit 5 --remove-reviewer user2 --milestone "v1.0"`,
-	Args: cobra.ExactArgs(1),
-	RunE: runPREdit,
-}
-
-var prCheckoutCmd = &cobra.Command{
-	Use:   "checkout <number>",
-	Short: "Check out a pull request locally",
-	Long:  "Check out the head branch of a pull request.",
-	Example: `  # Check out PR #5
-  fj pr checkout 5`,
-	Args: cobra.ExactArgs(1),
-	RunE: runPRCheckout,
+	Args:  cobra.ExactArgs(1),
+	RunE:  runPRMerge,
 }
 
 func init() {
@@ -147,76 +57,25 @@ func init() {
 	prCmd.AddCommand(prViewCmd)
 	prCmd.AddCommand(prCreateCmd)
 	prCmd.AddCommand(prMergeCmd)
-	prCmd.AddCommand(prCloseCmd)
-	prCmd.AddCommand(prReopenCmd)
-	prCmd.AddCommand(prEditCmd)
-	prCmd.AddCommand(prCheckoutCmd)
-
-	prCloseCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	prCloseCmd.Flags().StringP("comment", "c", "", "Comment body to add before closing")
-
-	prReopenCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
 
 	prListCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
 	prListCmd.Flags().StringP("state", "s", "open", "Filter by state: open, closed, all")
-	prListCmd.Flags().IntP("limit", "L", 30, "Maximum number of results")
-	prListCmd.Flags().StringP("assignee", "a", "", "Filter by assignee username")
-	prListCmd.Flags().String("author", "", "Filter by author username")
-	prListCmd.Flags().StringSliceP("label", "l", nil, "Filter by label names")
-	prListCmd.Flags().StringP("search", "S", "", "Search keyword filter")
-	prListCmd.Flags().Bool("draft", false, "Filter by draft status")
-	prListCmd.Flags().String("head", "", "Filter by head branch")
-	prListCmd.Flags().String("base", "", "Filter by base branch")
-	prListCmd.Flags().BoolP("web", "w", false, "Open list in web browser")
-	addJSONFlags(prListCmd, "Output pull requests as JSON")
 
 	prViewCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	addJSONFlags(prViewCmd, "Output pull request as JSON")
-	prViewCmd.Flags().BoolP("web", "w", false, "Open in web browser")
 
 	prCreateCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
 	prCreateCmd.Flags().StringP("title", "t", "", "Title for the pull request")
 	prCreateCmd.Flags().StringP("body", "b", "", "Body for the pull request")
 	prCreateCmd.Flags().StringP("head", "H", "", "Head branch")
 	prCreateCmd.Flags().StringP("base", "B", "", "Base branch (default: main)")
-	prCreateCmd.Flags().StringSliceP("assignee", "a", []string{}, "Assign people by their login. Use \"@me\" to self-assign.")
-	prCreateCmd.Flags().BoolP("draft", "d", false, "Create as draft pull request")
-	prCreateCmd.Flags().StringSliceP("reviewer", "r", nil, "Request reviewers by username")
-	prCreateCmd.Flags().StringSliceP("label", "l", nil, "Add labels by name")
-	prCreateCmd.Flags().StringP("milestone", "m", "", "Set milestone by name")
 
 	prMergeCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
 	prMergeCmd.Flags().String("merge-method", "merge", "Merge method: merge, rebase, squash")
-	prMergeCmd.Flags().BoolP("yes", "y", false, "Skip confirmation prompt")
-	prMergeCmd.Flags().BoolP("delete-branch", "d", false, "Delete the branch after merge")
-	prMergeCmd.Flags().Bool("auto", false, "Merge automatically when checks succeed")
-
-	prCheckoutCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-
-	prEditCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	prEditCmd.Flags().StringP("title", "t", "", "New title for the pull request")
-	prEditCmd.Flags().StringP("body", "b", "", "New body for the pull request")
-	prEditCmd.Flags().StringP("base", "B", "", "New base branch for the pull request")
-	prEditCmd.Flags().StringSlice("add-assignee", nil, "Assignees to add (login names)")
-	prEditCmd.Flags().StringSlice("remove-assignee", nil, "Assignees to remove (login names)")
-	prEditCmd.Flags().StringSlice("add-label", nil, "Labels to add (by name)")
-	prEditCmd.Flags().StringSlice("remove-label", nil, "Labels to remove (by name)")
-	prEditCmd.Flags().StringSlice("add-reviewer", nil, "Reviewers to add (login names)")
-	prEditCmd.Flags().StringSlice("remove-reviewer", nil, "Reviewers to remove (login names)")
-	prEditCmd.Flags().String("milestone", "", "Milestone name to set (empty string to clear)")
 }
 
 func runPRList(cmd *cobra.Command, args []string) error {
 	repo, _ := cmd.Flags().GetString("repo")
 	state, _ := cmd.Flags().GetString("state")
-	limit, _ := cmd.Flags().GetInt("limit")
-	assignee, _ := cmd.Flags().GetString("assignee")
-	author, _ := cmd.Flags().GetString("author")
-	labels, _ := cmd.Flags().GetStringSlice("label")
-	search, _ := cmd.Flags().GetString("search")
-	draft, _ := cmd.Flags().GetBool("draft")
-	head, _ := cmd.Flags().GetString("head")
-	base, _ := cmd.Flags().GetString("base")
 
 	owner, name, err := parseRepo(repo)
 	if err != nil {
@@ -228,15 +87,11 @@ func runPRList(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return err
 	}
 
-	if web, _ := cmd.Flags().GetBool("web"); web {
-		return ios.OpenInBrowser(fmt.Sprintf("https://%s/%s/%s/pulls", client.Hostname(), owner, name))
-	}
-
 	var stateType gitea.StateType
 	switch strings.ToLower(state) {
 	case "open":
@@ -249,347 +104,31 @@ func runPRList(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("invalid state: %s", state)
 	}
 
-	needsClientFilter := assignee != "" || author != "" || len(labels) > 0 || search != "" || draft || head != "" || base != ""
-
-	ios.StartSpinner("Fetching pull requests...")
-	// When client-side filtering is needed, pull pages until exhausted (no
-	// limit) so we can apply filters; otherwise paginate up to the user's
-	// limit. Either way, paginate — `PageSize: limit` capped at 50 silently.
-	fetchPage := func(page, pageSize int) ([]*gitea.PullRequest, error) {
-		batch, _, err := client.ListRepoPullRequests(owner, name, gitea.ListPullRequestsOptions{
-			State:       stateType,
-			ListOptions: gitea.ListOptions{Page: page, PageSize: pageSize},
-		})
-		return batch, err
-	}
-	var prs []*gitea.PullRequest
-	if needsClientFilter {
-		prs, err = paginateGitea(0, fetchPage) // pull all, then filter + limit
-		if err == nil {
-			prs = filterPRs(prs, author, assignee, labels, search, draft, head, base)
-			if limit > 0 && len(prs) > limit {
-				prs = prs[:limit]
-			}
-		}
-	} else {
-		prs, err = paginateGitea(limit, fetchPage)
-	}
-	ios.StopSpinner()
+	prs, _, err := client.ListRepoPullRequests(owner, name, gitea.ListPullRequestsOptions{
+		State: stateType,
+	})
 	if err != nil {
 		return fmt.Errorf("failed to list pull requests: %w", err)
 	}
 
-	if wantJSON(cmd) {
-		return outputJSON(cmd, prs)
-	}
-
 	if len(prs) == 0 {
-		fmt.Fprintf(ios.Out, "No %s pull requests in %s/%s\n", state, owner, name)
+		fmt.Printf("No %s pull requests in %s/%s\n", state, owner, name)
 		return nil
 	}
 
-	tp := ios.NewTablePrinter()
-	tp.AddHeader("NUMBER", "TITLE", "BRANCH", "STATE")
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+	_, _ = fmt.Fprintf(w, "NUMBER\tTITLE\tBRANCH\tSTATE\n")
 	for _, pr := range prs {
-		tp.AddRow(fmt.Sprintf("#%d", pr.Index), pr.Title, pr.Head.Ref, string(pr.State))
+		_, _ = fmt.Fprintf(w, "#%d\t%s\t%s\t%s\n", pr.Index, pr.Title, pr.Head.Ref, pr.State)
 	}
-	return tp.Render()
-}
+	_ = w.Flush()
 
-func filterPRs(prs []*gitea.PullRequest, author, assignee string, labels []string, search string, draft bool, head, base string) []*gitea.PullRequest {
-	var result []*gitea.PullRequest
-	for _, pr := range prs {
-		if author != "" && !strings.EqualFold(pr.Poster.UserName, author) {
-			continue
-		}
-		if assignee != "" {
-			found := false
-			for _, a := range pr.Assignees {
-				if strings.EqualFold(a.UserName, assignee) {
-					found = true
-					break
-				}
-			}
-			if !found {
-				continue
-			}
-		}
-		if len(labels) > 0 {
-			prLabelNames := make(map[string]bool)
-			for _, l := range pr.Labels {
-				prLabelNames[strings.ToLower(l.Name)] = true
-			}
-			allFound := true
-			for _, label := range labels {
-				if !prLabelNames[strings.ToLower(label)] {
-					allFound = false
-					break
-				}
-			}
-			if !allFound {
-				continue
-			}
-		}
-		if search != "" && !strings.Contains(strings.ToLower(pr.Title), strings.ToLower(search)) {
-			continue
-		}
-		if draft && !pr.Draft {
-			continue
-		}
-		if head != "" && !strings.EqualFold(pr.Head.Ref, head) {
-			continue
-		}
-		if base != "" && !strings.EqualFold(pr.Base.Ref, base) {
-			continue
-		}
-		result = append(result, pr)
-	}
-	return result
+	return nil
 }
 
 func runPRView(cmd *cobra.Command, args []string) error {
 	repo, _ := cmd.Flags().GetString("repo")
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	var prNumber int64
-	if len(args) == 0 {
-		// Try to find PR for current branch
-		branch, branchErr := gitpkg.GetCurrentBranch()
-		if branchErr != nil {
-			return fmt.Errorf("no pull request number specified and could not detect current branch: %w", branchErr)
-		}
-
-		ios.StartSpinner("Finding pull request for branch...")
-		prs, _, listErr := client.ListRepoPullRequests(owner, name, gitea.ListPullRequestsOptions{
-			State: gitea.StateOpen,
-		})
-		ios.StopSpinner()
-		if listErr != nil {
-			return fmt.Errorf("failed to list pull requests: %w", listErr)
-		}
-
-		var found bool
-		for _, pr := range prs {
-			if pr.Head.Ref == branch {
-				prNumber = pr.Index
-				found = true
-				break
-			}
-		}
-		if !found {
-			return fmt.Errorf("no open pull request found for branch %q", branch)
-		}
-	} else {
-		prNumber, err = parseIssueArg(args[0])
-		if err != nil {
-			return fmt.Errorf("invalid pull request number: %w", err)
-		}
-	}
-
-	ios.StartSpinner("Fetching pull request...")
-	pr, _, err := client.GetPullRequest(owner, name, prNumber)
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to get pull request: %w", err)
-	}
-
-	if web, _ := cmd.Flags().GetBool("web"); web {
-		return ios.OpenInBrowser(pr.HTMLURL)
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, pr)
-	}
-
-	if err := ios.StartPager(); err != nil {
-		fmt.Fprintf(ios.ErrOut, "warning: failed to start pager: %v\n", err)
-	}
-	defer ios.StopPager()
-
-	cs := ios.ColorScheme()
-	isTTY := ios.IsStdoutTTY()
-
-	fmt.Fprintf(ios.Out, "%s Pull Request #%d\n", cs.Bold(""), pr.Index)
-	fmt.Fprintf(ios.Out, "Title: %s\n", cs.Bold(pr.Title))
-	fmt.Fprintf(ios.Out, "State: %s\n", pr.State)
-	fmt.Fprintf(ios.Out, "Author: %s\n", pr.Poster.UserName)
-	fmt.Fprintf(ios.Out, "Branch: %s -> %s\n", pr.Head.Ref, pr.Base.Ref)
-	if pr.Created != nil {
-		fmt.Fprintf(ios.Out, "Created: %s\n", text.FormatDate(*pr.Created, isTTY))
-	}
-	if pr.Updated != nil {
-		fmt.Fprintf(ios.Out, "Updated: %s\n", text.FormatDate(*pr.Updated, isTTY))
-	}
-	if pr.Body != "" {
-		fmt.Fprintf(ios.Out, "\n%s\n", pr.Body)
-	}
-
-	return nil
-}
-
-func runPRCreate(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	title, _ := cmd.Flags().GetString("title")
-	body, _ := cmd.Flags().GetString("body")
-	head, _ := cmd.Flags().GetString("head")
-	base, _ := cmd.Flags().GetString("base")
-	assignees, _ := cmd.Flags().GetStringSlice("assignee")
-	draft, _ := cmd.Flags().GetBool("draft")
-	reviewers, _ := cmd.Flags().GetStringSlice("reviewer")
-	labelNames, _ := cmd.Flags().GetStringSlice("label")
-	milestoneName, _ := cmd.Flags().GetString("milestone")
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	// Interactive mode: prompt for missing fields when TTY
-	if title == "" && ios.IsStdinTTY() {
-		title, err = promptLine("Title: ")
-		if err != nil {
-			return err
-		}
-		if title == "" {
-			return fmt.Errorf("title is required")
-		}
-	} else if title == "" {
-		return fmt.Errorf("title is required (use -t flag)")
-	}
-
-	if head == "" && ios.IsStdinTTY() {
-		// Default to current branch
-		branch, branchErr := gitpkg.GetCurrentBranch()
-		if branchErr == nil {
-			head = branch
-			fmt.Fprintf(ios.ErrOut, "Using current branch %q as head\n", head)
-		} else {
-			head, err = promptLine("Head branch: ")
-			if err != nil {
-				return err
-			}
-		}
-	}
-	if head == "" {
-		return fmt.Errorf("head branch is required (use -H flag)")
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	if base == "" {
-		ios.StartSpinner("Fetching repository info...")
-		repoInfo, _, err := client.GetRepo(owner, name)
-		ios.StopSpinner()
-		if err != nil {
-			return fmt.Errorf("failed to get repository info: %w", err)
-		}
-		base = repoInfo.DefaultBranch
-	}
-
-	// Resolve @me in assignees
-	resolvedAssignees := make([]string, 0, len(assignees))
-	for _, assignee := range assignees {
-		if assignee == "@me" {
-			user, _, err := client.GetMyUserInfo()
-			if err != nil {
-				return fmt.Errorf("failed to get current user info: %w", err)
-			}
-			resolvedAssignees = append(resolvedAssignees, user.UserName)
-		} else {
-			resolvedAssignees = append(resolvedAssignees, assignee)
-		}
-	}
-
-	// Resolve label names to IDs
-	var labelIDs []int64
-	if len(labelNames) > 0 {
-		labelIDs, err = resolveLabelIDs(client, owner, name, labelNames)
-		if err != nil {
-			return err
-		}
-	}
-
-	// Resolve milestone name to ID
-	var milestoneID int64
-	if milestoneName != "" {
-		milestones, _, msErr := client.ListRepoMilestones(owner, name, gitea.ListMilestoneOption{})
-		if msErr != nil {
-			return fmt.Errorf("failed to list milestones: %w", msErr)
-		}
-		found := false
-		for _, ms := range milestones {
-			if ms.Title == milestoneName {
-				milestoneID = ms.ID
-				found = true
-				break
-			}
-		}
-		if !found {
-			return fmt.Errorf("milestone not found: %s", milestoneName)
-		}
-	}
-
-	ios.StartSpinner("Creating pull request...")
-	pr, _, err := client.CreatePullRequest(owner, name, gitea.CreatePullRequestOption{
-		Title:     title,
-		Body:      body,
-		Head:      head,
-		Base:      base,
-		Assignees: resolvedAssignees,
-		Reviewers: reviewers,
-		Labels:    labelIDs,
-		Milestone: milestoneID,
-	})
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to create pull request: %w", err)
-	}
-
-	// Set draft status via raw API if needed
-	if draft {
-		_, draftErr := client.DoJSON("PATCH", fmt.Sprintf("/api/v1/repos/%s/%s/pulls/%d", owner, name, pr.Index), map[string]any{"draft": true}, nil)
-		if draftErr != nil {
-			return fmt.Errorf("failed to set pull request as draft: %w", draftErr)
-		}
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Pull request created: #%d\n", cs.SuccessIcon(), pr.Index)
-	fmt.Fprintf(ios.Out, "View at: %s\n", pr.HTMLURL)
-
-	return nil
-}
-
-func runPRMerge(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	mergeMethod, _ := cmd.Flags().GetString("merge-method")
-	yes, _ := cmd.Flags().GetBool("yes")
-	deleteBranch, _ := cmd.Flags().GetBool("delete-branch")
-	autoMerge, _ := cmd.Flags().GetBool("auto")
-
-	prNumber, err := parseIssueArg(args[0])
+	prNumber, err := strconv.ParseInt(args[0], 10, 64)
 	if err != nil {
 		return fmt.Errorf("invalid pull request number: %w", err)
 	}
@@ -604,7 +143,99 @@ func runPRMerge(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
+	if err != nil {
+		return err
+	}
+
+	pr, _, err := client.GetPullRequest(owner, name, prNumber)
+	if err != nil {
+		return fmt.Errorf("failed to get pull request: %w", err)
+	}
+
+	fmt.Printf("Pull Request #%d\n", pr.Index)
+	fmt.Printf("Title: %s\n", pr.Title)
+	fmt.Printf("State: %s\n", pr.State)
+	fmt.Printf("Author: %s\n", pr.Poster.UserName)
+	fmt.Printf("Branch: %s -> %s\n", pr.Head.Ref, pr.Base.Ref)
+	fmt.Printf("Created: %s\n", pr.Created.Format("2006-01-02 15:04:05"))
+	fmt.Printf("Updated: %s\n", pr.Updated.Format("2006-01-02 15:04:05"))
+	if pr.Body != "" {
+		fmt.Printf("\n%s\n", pr.Body)
+	}
+
+	return nil
+}
+
+func runPRCreate(cmd *cobra.Command, args []string) error {
+	repo, _ := cmd.Flags().GetString("repo")
+	title, _ := cmd.Flags().GetString("title")
+	body, _ := cmd.Flags().GetString("body")
+	head, _ := cmd.Flags().GetString("head")
+	base, _ := cmd.Flags().GetString("base")
+
+	if base == "" {
+		base = "main"
+	}
+
+	owner, name, err := parseRepo(repo)
+	if err != nil {
+		return err
+	}
+
+	if title == "" {
+		return fmt.Errorf("title is required")
+	}
+
+	if head == "" {
+		return fmt.Errorf("head branch is required")
+	}
+
+	cfg, err := config.Load()
+	if err != nil {
+		return err
+	}
+
+	client, err := api.NewClientFromConfig(cfg, "")
+	if err != nil {
+		return err
+	}
+
+	pr, _, err := client.CreatePullRequest(owner, name, gitea.CreatePullRequestOption{
+		Title: title,
+		Body:  body,
+		Head:  head,
+		Base:  base,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to create pull request: %w", err)
+	}
+
+	fmt.Printf("Pull request created: #%d\n", pr.Index)
+	fmt.Printf("View at: %s\n", pr.HTMLURL)
+
+	return nil
+}
+
+func runPRMerge(cmd *cobra.Command, args []string) error {
+	repo, _ := cmd.Flags().GetString("repo")
+	mergeMethod, _ := cmd.Flags().GetString("merge-method")
+	prNumber, err := strconv.ParseInt(args[0], 10, 64)
+	if err != nil {
+		return fmt.Errorf("invalid pull request number: %w", err)
+	}
+
+	owner, name, err := parseRepo(repo)
+	if err != nil {
+		return err
+	}
+
+	cfg, err := config.Load()
+	if err != nil {
+		return err
+	}
+
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return err
 	}
@@ -621,432 +252,33 @@ func runPRMerge(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("invalid merge method: %s", mergeMethod)
 	}
 
-	if !yes {
-		confirmed, err := ios.ConfirmAction(fmt.Sprintf("Merge pull request #%d via %s?", prNumber, mergeMethod))
-		if err != nil {
-			return err
-		}
-		if !confirmed {
-			fmt.Fprintln(ios.ErrOut, "Aborted")
-			return nil
-		}
-	}
-
-	ios.StartSpinner("Merging pull request...")
 	_, _, err = client.MergePullRequest(owner, name, prNumber, gitea.MergePullRequestOption{
-		Style:                  method,
-		DeleteBranchAfterMerge: deleteBranch,
-		MergeWhenChecksSucceed: autoMerge,
+		Style: method,
 	})
-	ios.StopSpinner()
 	if err != nil {
 		return fmt.Errorf("failed to merge pull request: %w", err)
 	}
 
-	cs := ios.ColorScheme()
-	if autoMerge {
-		fmt.Fprintf(ios.Out, "%s Auto-merge enabled for PR #%d\n", cs.SuccessIcon(), prNumber)
-	} else {
-		fmt.Fprintf(ios.Out, "%s Pull request #%d merged successfully\n", cs.SuccessIcon(), prNumber)
-	}
+	fmt.Printf("Pull request #%d merged successfully\n", prNumber)
 
 	return nil
 }
 
-func runPRClose(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	commentBody, _ := cmd.Flags().GetString("comment")
-	prNumber, err := parseIssueArg(args[0])
-	if err != nil {
-		return fmt.Errorf("invalid pull request number: %w", err)
-	}
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	if commentBody != "" {
-		ios.StartSpinner("Adding comment...")
-		_, _, err = client.CreateIssueComment(owner, name, prNumber, gitea.CreateIssueCommentOption{
-			Body: commentBody,
-		})
-		ios.StopSpinner()
-		if err != nil {
-			return fmt.Errorf("failed to create comment: %w", err)
+func parseRepo(repo string) (string, string, error) {
+	// If repo flag is provided, use it
+	if repo != "" {
+		parts := strings.Split(repo, "/")
+		if len(parts) != 2 {
+			return "", "", fmt.Errorf("invalid repository format: %s (expected: owner/name)", repo)
 		}
+		return parts[0], parts[1], nil
 	}
 
-	ios.StartSpinner("Closing pull request...")
-	stateClosed := gitea.StateClosed
-	_, _, err = client.EditPullRequest(owner, name, prNumber, gitea.EditPullRequestOption{
-		State: &stateClosed,
-	})
-	ios.StopSpinner()
+	// Try to auto-detect from git
+	owner, name, err := git.DetectRepo()
 	if err != nil {
-		return fmt.Errorf("failed to close pull request: %w", err)
+		return "", "", fmt.Errorf("repository flag is required (use -R owner/name) or run from a git repository: %w", err)
 	}
 
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Pull request #%d closed\n", cs.SuccessIcon(), prNumber)
-
-	return nil
-}
-
-func runPRReopen(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	prNumber, err := parseIssueArg(args[0])
-	if err != nil {
-		return fmt.Errorf("invalid pull request number: %w", err)
-	}
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Reopening pull request...")
-	stateOpen := gitea.StateOpen
-	_, _, err = client.EditPullRequest(owner, name, prNumber, gitea.EditPullRequestOption{
-		State: &stateOpen,
-	})
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to reopen pull request: %w", err)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Pull request #%d reopened\n", cs.SuccessIcon(), prNumber)
-
-	return nil
-}
-
-func runPRCheckout(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-
-	prNumber, err := parseIssueArg(args[0])
-	if err != nil {
-		return fmt.Errorf("invalid pull request number: %w", err)
-	}
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Fetching pull request...")
-	pr, _, err := client.GetPullRequest(owner, name, prNumber)
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to get pull request: %w", err)
-	}
-
-	headBranch := pr.Head.Ref
-	headRepo := pr.Head.Repository
-
-	// Determine if same-repo or cross-repo PR
-	isSameRepo := headRepo == nil || headRepo.FullName == fmt.Sprintf("%s/%s", owner, name)
-
-	if isSameRepo {
-		// Same repo: fetch and checkout
-		ios.StartSpinner("Checking out branch...")
-
-		gitFetch := exec.Command("git", "fetch", "origin", headBranch)
-		gitFetch.Stdout = ios.Out
-		gitFetch.Stderr = ios.ErrOut
-		if err := gitFetch.Run(); err != nil {
-			ios.StopSpinner()
-			return fmt.Errorf("failed to fetch branch: %w", err)
-		}
-
-		// Try to checkout existing branch first
-		gitCheckout := exec.Command("git", "checkout", headBranch)
-		gitCheckout.Stdout = ios.Out
-		gitCheckout.Stderr = ios.ErrOut
-		if err := gitCheckout.Run(); err != nil {
-			// Branch doesn't exist locally, create it tracking remote
-			gitCheckout = exec.Command("git", "checkout", "-b", headBranch, "origin/"+headBranch)
-			gitCheckout.Stdout = ios.Out
-			gitCheckout.Stderr = ios.ErrOut
-			if err := gitCheckout.Run(); err != nil {
-				ios.StopSpinner()
-				return fmt.Errorf("failed to checkout branch: %w", err)
-			}
-		} else {
-			// Branch existed, pull latest
-			gitPull := exec.Command("git", "pull")
-			gitPull.Stdout = ios.Out
-			gitPull.Stderr = ios.ErrOut
-			_ = gitPull.Run()
-		}
-		ios.StopSpinner()
-	} else {
-		// Cross-repo (fork): add remote and checkout
-		forkOwner := headRepo.Owner.UserName
-		forkCloneURL := headRepo.CloneURL
-
-		ios.StartSpinner("Checking out branch from fork...")
-
-		// Add fork as remote (ignore error if already exists)
-		gitRemoteAdd := exec.Command("git", "remote", "add", forkOwner, forkCloneURL)
-		gitRemoteAdd.Stdout = ios.Out
-		gitRemoteAdd.Stderr = ios.ErrOut
-		_ = gitRemoteAdd.Run() // ignore error if remote already exists
-
-		// Fetch from fork
-		gitFetch := exec.Command("git", "fetch", forkOwner)
-		gitFetch.Stdout = ios.Out
-		gitFetch.Stderr = ios.ErrOut
-		if err := gitFetch.Run(); err != nil {
-			ios.StopSpinner()
-			return fmt.Errorf("failed to fetch from fork: %w", err)
-		}
-
-		// Checkout the branch
-		gitCheckout := exec.Command("git", "checkout", "-b", headBranch, forkOwner+"/"+headBranch)
-		gitCheckout.Stdout = ios.Out
-		gitCheckout.Stderr = ios.ErrOut
-		if err := gitCheckout.Run(); err != nil {
-			ios.StopSpinner()
-			return fmt.Errorf("failed to checkout branch: %w", err)
-		}
-		ios.StopSpinner()
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Checked out PR #%d on branch %q\n", cs.SuccessIcon(), prNumber, headBranch)
-	return nil
-}
-
-func runPREdit(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	prNumber, err := parseIssueArg(args[0])
-	if err != nil {
-		return fmt.Errorf("invalid pull request number: %w", err)
-	}
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	// Check that at least one flag was provided
-	anyChanged := false
-	for _, flag := range []string{"title", "body", "base", "add-assignee", "remove-assignee",
-		"add-label", "remove-label", "add-reviewer", "remove-reviewer", "milestone"} {
-		if cmd.Flags().Changed(flag) {
-			anyChanged = true
-			break
-		}
-	}
-	if !anyChanged {
-		return fmt.Errorf("at least one of --title, --body, --base, --add-assignee, --remove-assignee, " +
-			"--add-label, --remove-label, --add-reviewer, --remove-reviewer, or --milestone must be provided")
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	// Build EditPullRequestOption from changed flags
-	editOpt := gitea.EditPullRequestOption{}
-	needsEditCall := false
-
-	if cmd.Flags().Changed("title") {
-		title, _ := cmd.Flags().GetString("title")
-		editOpt.Title = title
-		needsEditCall = true
-	}
-
-	if cmd.Flags().Changed("body") {
-		body, _ := cmd.Flags().GetString("body")
-		editOpt.Body = &body
-		needsEditCall = true
-	}
-
-	if cmd.Flags().Changed("base") {
-		base, _ := cmd.Flags().GetString("base")
-		editOpt.Base = base
-		needsEditCall = true
-	}
-
-	// Handle milestone
-	if cmd.Flags().Changed("milestone") {
-		milestoneName, _ := cmd.Flags().GetString("milestone")
-		if milestoneName == "" {
-			// Clear milestone by setting to 0
-			editOpt.Milestone = 0
-		} else {
-			milestones, _, msErr := client.ListRepoMilestones(owner, name, gitea.ListMilestoneOption{})
-			if msErr != nil {
-				return fmt.Errorf("failed to list milestones: %w", msErr)
-			}
-			var milestoneID int64
-			for _, ms := range milestones {
-				if ms.Title == milestoneName {
-					milestoneID = ms.ID
-					break
-				}
-			}
-			if milestoneID == 0 {
-				return fmt.Errorf("milestone not found: %s", milestoneName)
-			}
-			editOpt.Milestone = milestoneID
-		}
-		needsEditCall = true
-	}
-
-	// Handle assignees (add/remove requires fetching current PR)
-	addAssignees, _ := cmd.Flags().GetStringSlice("add-assignee")
-	removeAssignees, _ := cmd.Flags().GetStringSlice("remove-assignee")
-
-	if len(addAssignees) > 0 || len(removeAssignees) > 0 {
-		ios.StartSpinner("Fetching pull request...")
-		pr, _, prErr := client.GetPullRequest(owner, name, prNumber)
-		ios.StopSpinner()
-		if prErr != nil {
-			return fmt.Errorf("failed to get pull request: %w", prErr)
-		}
-
-		// Build current assignee set
-		assigneeSet := make(map[string]bool)
-		for _, a := range pr.Assignees {
-			assigneeSet[a.UserName] = true
-		}
-
-		// Add new assignees
-		for _, a := range addAssignees {
-			assigneeSet[a] = true
-		}
-
-		// Remove assignees
-		for _, a := range removeAssignees {
-			delete(assigneeSet, a)
-		}
-
-		// Convert back to slice
-		newAssignees := make([]string, 0, len(assigneeSet))
-		for a := range assigneeSet {
-			newAssignees = append(newAssignees, a)
-		}
-
-		editOpt.Assignees = newAssignees
-		needsEditCall = true
-	}
-
-	ios.StartSpinner("Updating pull request...")
-
-	// Perform the edit API call if needed
-	if needsEditCall {
-		_, _, err = client.EditPullRequest(owner, name, prNumber, editOpt)
-		if err != nil {
-			ios.StopSpinner()
-			return fmt.Errorf("failed to edit pull request: %w", err)
-		}
-	}
-
-	// Handle labels
-	addLabelNames, _ := cmd.Flags().GetStringSlice("add-label")
-	removeLabelNames, _ := cmd.Flags().GetStringSlice("remove-label")
-
-	if len(addLabelNames) > 0 {
-		labelIDs, labelErr := resolveLabelIDs(client, owner, name, addLabelNames)
-		if labelErr != nil {
-			ios.StopSpinner()
-			return labelErr
-		}
-		_, _, err = client.AddIssueLabels(owner, name, prNumber, gitea.IssueLabelsOption{
-			Labels: labelIDs,
-		})
-		if err != nil {
-			ios.StopSpinner()
-			return fmt.Errorf("failed to add labels: %w", err)
-		}
-	}
-
-	if len(removeLabelNames) > 0 {
-		labelIDs, labelErr := resolveLabelIDs(client, owner, name, removeLabelNames)
-		if labelErr != nil {
-			ios.StopSpinner()
-			return labelErr
-		}
-		for _, labelID := range labelIDs {
-			_, err = client.DeleteIssueLabel(owner, name, prNumber, labelID)
-			if err != nil {
-				ios.StopSpinner()
-				return fmt.Errorf("failed to remove label %d: %w", labelID, err)
-			}
-		}
-	}
-
-	// Handle reviewers
-	addReviewers, _ := cmd.Flags().GetStringSlice("add-reviewer")
-	removeReviewers, _ := cmd.Flags().GetStringSlice("remove-reviewer")
-
-	if len(addReviewers) > 0 {
-		reviewerReq := map[string][]string{
-			"reviewers": addReviewers,
-		}
-		endpoint := fmt.Sprintf("/api/v1/repos/%s/%s/pulls/%d/requested_reviewers", owner, name, prNumber)
-		_, err := client.DoJSON(http.MethodPost, endpoint, reviewerReq, nil)
-		if err != nil {
-			ios.StopSpinner()
-			return fmt.Errorf("failed to add reviewers: %w", err)
-		}
-	}
-
-	if len(removeReviewers) > 0 {
-		reviewerReq := map[string][]string{
-			"reviewers": removeReviewers,
-		}
-		endpoint := fmt.Sprintf("/api/v1/repos/%s/%s/pulls/%d/requested_reviewers", owner, name, prNumber)
-		_, err := client.DoJSON(http.MethodDelete, endpoint, reviewerReq, nil)
-		if err != nil {
-			ios.StopSpinner()
-			return fmt.Errorf("failed to remove reviewers: %w", err)
-		}
-	}
-
-	ios.StopSpinner()
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Pull request #%d updated\n", cs.SuccessIcon(), prNumber)
-
-	return nil
+	return owner, name, nil
 }
diff --git a/cmd/pr_checks.go b/cmd/pr_checks.go
deleted file mode 100644
index fdcf446..0000000
--- a/cmd/pr_checks.go
+++ /dev/null
@@ -1,99 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-
-	"code.gitea.io/sdk/gitea"
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
-	"forgejo.zerova.net/public/fj/internal/iostreams"
-	"github.com/spf13/cobra"
-)
-
-var prChecksCmd = &cobra.Command{
-	Use:   "checks <number>",
-	Short: "Show CI status checks for a pull request",
-	Long:  "Show the status of CI checks for a pull request.",
-	Example: `  # Show checks for PR #5
-  fj pr checks 5
-
-  # Output as JSON
-  fj pr checks 5 --json`,
-	Args: cobra.ExactArgs(1),
-	RunE: runPRChecks,
-}
-
-func init() {
-	prCmd.AddCommand(prChecksCmd)
-	prChecksCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	addJSONFlags(prChecksCmd, "Output checks as JSON")
-}
-
-func runPRChecks(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	prNumber, err := parseIssueArg(args[0])
-	if err != nil {
-		return fmt.Errorf("invalid pull request number: %w", err)
-	}
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Fetching pull request...")
-	pr, _, err := client.GetPullRequest(owner, name, prNumber)
-	if err != nil {
-		ios.StopSpinner()
-		return fmt.Errorf("failed to get pull request: %w", err)
-	}
-
-	statuses, _, err := client.ListStatuses(owner, name, pr.Head.Sha, gitea.ListStatusesOption{})
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to get commit statuses: %w", err)
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, statuses)
-	}
-
-	if len(statuses) == 0 {
-		fmt.Fprintf(ios.Out, "No status checks found for PR #%d\n", prNumber)
-		return nil
-	}
-
-	cs := ios.ColorScheme()
-	tp := ios.NewTablePrinter()
-	tp.AddHeader("STATUS", "CONTEXT", "DESCRIPTION")
-	for _, s := range statuses {
-		status := formatCheckStatus(s.State, cs)
-		tp.AddRow(status, s.Context, s.Description)
-	}
-	return tp.Render()
-}
-
-func formatCheckStatus(state gitea.StatusState, cs *iostreams.ColorScheme) string {
-	switch state {
-	case gitea.StatusSuccess:
-		return cs.Green("pass")
-	case gitea.StatusFailure, gitea.StatusError:
-		return cs.Red("fail")
-	case gitea.StatusPending:
-		return cs.Yellow("pending")
-	case gitea.StatusWarning:
-		return cs.Yellow("warn")
-	default:
-		return string(state)
-	}
-}
diff --git a/cmd/pr_diff.go b/cmd/pr_diff.go
deleted file mode 100644
index 18b4b2c..0000000
--- a/cmd/pr_diff.go
+++ /dev/null
@@ -1,270 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"strings"
-
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
-	"github.com/spf13/cobra"
-)
-
-var prDiffCmd = &cobra.Command{
-	Use:   "diff <number>",
-	Short: "Show the diff for a pull request",
-	Long:  "Fetch and display the diff for a pull request.",
-	Example: `  # View the diff for PR #123
-  fj pr diff 123
-
-  # Colorized diff output
-  fj pr diff 123 --color always
-
-  # Show only changed file names
-  fj pr diff 123 --name-only
-
-  # Show diffstat summary
-  fj pr diff 123 --stat`,
-	Args: cobra.ExactArgs(1),
-	RunE: runPRDiff,
-}
-
-func init() {
-	prCmd.AddCommand(prDiffCmd)
-
-	prDiffCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	prDiffCmd.Flags().String("color", "auto", "Colorize the diff output: auto, always, never")
-	prDiffCmd.Flags().Bool("name-only", false, "Show only changed file names")
-	prDiffCmd.Flags().Bool("stat", false, "Show diffstat summary")
-}
-
-func runPRDiff(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	colorMode, _ := cmd.Flags().GetString("color")
-	nameOnly, _ := cmd.Flags().GetBool("name-only")
-	stat, _ := cmd.Flags().GetBool("stat")
-
-	prNumber, err := parseIssueArg(args[0])
-	if err != nil {
-		return fmt.Errorf("invalid pull request number: %w", err)
-	}
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	diffURL := fmt.Sprintf("https://%s/api/v1/repos/%s/%s/pulls/%d.diff",
-		client.Hostname(), owner, name, prNumber)
-
-	ios.StartSpinner("Fetching diff...")
-	diff, err := client.GetRawLog(diffURL)
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to get pull request diff: %w", err)
-	}
-
-	if nameOnly {
-		return printNameOnly(diff)
-	}
-
-	if stat {
-		return printDiffStat(diff)
-	}
-
-	// Start pager for diffs
-	if err := ios.StartPager(); err != nil {
-		fmt.Fprintf(ios.ErrOut, "warning: failed to start pager: %v\n", err)
-	}
-	defer ios.StopPager()
-
-	useColor := shouldColorize(colorMode)
-	if useColor {
-		return printColorizedDiff(diff)
-	}
-
-	fmt.Fprint(ios.Out, diff)
-	return nil
-}
-
-// shouldColorize determines whether to colorize output based on the color flag.
-func shouldColorize(mode string) bool {
-	switch strings.ToLower(mode) {
-	case "always":
-		return true
-	case "never":
-		return false
-	default: // "auto"
-		return ios.ColorEnabled()
-	}
-}
-
-// printNameOnly extracts and prints changed file names from the diff.
-func printNameOnly(diff string) error {
-	seen := make(map[string]bool)
-	for _, line := range strings.Split(diff, "\n") {
-		if strings.HasPrefix(line, "+++ b/") {
-			name := strings.TrimPrefix(line, "+++ b/")
-			if name != "" && !seen[name] {
-				seen[name] = true
-				fmt.Fprintln(ios.Out, name)
-			}
-		}
-	}
-	return nil
-}
-
-// fileStat holds per-file diff statistics.
-type fileStat struct {
-	name      string
-	additions int
-	deletions int
-}
-
-// printDiffStat parses the diff and prints a diffstat summary.
-func printDiffStat(diff string) error {
-	var stats []fileStat
-	var current *fileStat
-	inHeader := true
-
-	for _, line := range strings.Split(diff, "\n") {
-		if strings.HasPrefix(line, "diff --git ") {
-			if current != nil {
-				stats = append(stats, *current)
-			}
-			current = &fileStat{}
-			inHeader = true
-			continue
-		}
-		if current == nil {
-			continue
-		}
-		if strings.HasPrefix(line, "+++ b/") {
-			current.name = strings.TrimPrefix(line, "+++ b/")
-			continue
-		}
-		if strings.HasPrefix(line, "@@") {
-			inHeader = false
-			continue
-		}
-		if inHeader {
-			continue
-		}
-		if strings.HasPrefix(line, "+") {
-			current.additions++
-		} else if strings.HasPrefix(line, "-") {
-			current.deletions++
-		}
-	}
-	if current != nil && current.name != "" {
-		stats = append(stats, *current)
-	}
-
-	if len(stats) == 0 {
-		fmt.Fprintln(ios.Out, "0 files changed")
-		return nil
-	}
-
-	cs := ios.ColorScheme()
-
-	// Find the longest file name for alignment
-	maxNameLen := 0
-	maxChanges := 0
-	for _, s := range stats {
-		if len(s.name) > maxNameLen {
-			maxNameLen = len(s.name)
-		}
-		total := s.additions + s.deletions
-		if total > maxChanges {
-			maxChanges = total
-		}
-	}
-
-	// Cap the bar width
-	barWidth := maxChanges
-	if barWidth > 50 {
-		barWidth = 50
-	}
-
-	totalAdditions := 0
-	totalDeletions := 0
-
-	for _, s := range stats {
-		total := s.additions + s.deletions
-		totalAdditions += s.additions
-		totalDeletions += s.deletions
-
-		var bar string
-		if maxChanges > 0 {
-			scaledAdd := s.additions
-			scaledDel := s.deletions
-			if maxChanges > 50 {
-				scaledAdd = s.additions * 50 / maxChanges
-				scaledDel = s.deletions * 50 / maxChanges
-				if s.additions > 0 && scaledAdd == 0 {
-					scaledAdd = 1
-				}
-				if s.deletions > 0 && scaledDel == 0 {
-					scaledDel = 1
-				}
-			}
-			bar = cs.Green(strings.Repeat("+", scaledAdd)) + cs.Red(strings.Repeat("-", scaledDel))
-		}
-
-		fmt.Fprintf(ios.Out, " %-*s | %4d %s\n", maxNameLen, s.name, total, bar)
-	}
-
-	fmt.Fprintf(ios.Out, " %d file", len(stats))
-	if len(stats) != 1 {
-		fmt.Fprint(ios.Out, "s")
-	}
-	fmt.Fprintf(ios.Out, " changed, %d insertion", totalAdditions)
-	if totalAdditions != 1 {
-		fmt.Fprint(ios.Out, "s")
-	}
-	fmt.Fprintf(ios.Out, "(+), %d deletion", totalDeletions)
-	if totalDeletions != 1 {
-		fmt.Fprint(ios.Out, "s")
-	}
-	fmt.Fprintln(ios.Out, "(-)")
-
-	return nil
-}
-
-// printColorizedDiff prints the diff with ANSI color codes using ColorScheme.
-func printColorizedDiff(diff string) error {
-	cs := ios.ColorScheme()
-	for _, line := range strings.Split(diff, "\n") {
-		switch {
-		case strings.HasPrefix(line, "diff --git "):
-			fmt.Fprintln(ios.Out, cs.Bold(line))
-		case strings.HasPrefix(line, "index "),
-			strings.HasPrefix(line, "--- "),
-			strings.HasPrefix(line, "+++ "),
-			strings.HasPrefix(line, "new file"),
-			strings.HasPrefix(line, "deleted file"),
-			strings.HasPrefix(line, "similarity index"),
-			strings.HasPrefix(line, "rename from"),
-			strings.HasPrefix(line, "rename to"):
-			fmt.Fprintln(ios.Out, cs.Bold(line))
-		case strings.HasPrefix(line, "@@"):
-			fmt.Fprintln(ios.Out, cs.Cyan(line))
-		case strings.HasPrefix(line, "+"):
-			fmt.Fprintln(ios.Out, cs.Green(line))
-		case strings.HasPrefix(line, "-"):
-			fmt.Fprintln(ios.Out, cs.Red(line))
-		default:
-			fmt.Fprintln(ios.Out, line)
-		}
-	}
-	return nil
-}
diff --git a/cmd/pr_review.go b/cmd/pr_review.go
deleted file mode 100644
index 87a1314..0000000
--- a/cmd/pr_review.go
+++ /dev/null
@@ -1,234 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"io"
-	"os"
-
-	"code.gitea.io/sdk/gitea"
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
-	"github.com/spf13/cobra"
-)
-
-var prCommentCmd = &cobra.Command{
-	Use:   "comment <number>",
-	Short: "Add a comment to a pull request",
-	Long:  "Add a comment to an existing pull request.",
-	Example: `  # Add a comment
-  fj pr comment 123 -b "Looks good!"
-
-  # Comment from a file
-  fj pr comment 123 --body-file review-notes.md
-
-  # Comment from stdin
-  echo "LGTM" | fj pr comment 123 --body-file -
-
-  # Output as JSON
-  fj pr comment 123 -b "Nice work" --json`,
-	Args: cobra.ExactArgs(1),
-	RunE: runPRComment,
-}
-
-var prReviewCmd = &cobra.Command{
-	Use:   "review <number>",
-	Short: "Submit a review on a pull request",
-	Long:  "Submit a review on a pull request. Exactly one of --approve, --request-changes, or --comment must be specified.",
-	Example: `  # Approve a PR
-  fj pr review 123 --approve -b "LGTM"
-
-  # Request changes
-  fj pr review 123 --request-changes -b "Please fix the error handling"
-
-  # Submit a review comment
-  fj pr review 123 --comment -b "Some observations"
-
-  # Request changes with body from file
-  fj pr review 123 --request-changes --body-file feedback.md`,
-	Args: cobra.ExactArgs(1),
-	RunE: runPRReview,
-}
-
-func init() {
-	prCmd.AddCommand(prCommentCmd)
-	prCmd.AddCommand(prReviewCmd)
-
-	prCommentCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	prCommentCmd.Flags().StringP("body", "b", "", "Comment body")
-	prCommentCmd.Flags().String("body-file", "", "Read body from file (use \"-\" for stdin)")
-	addJSONFlags(prCommentCmd, "Output created comment as JSON")
-
-	prReviewCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	prReviewCmd.Flags().BoolP("approve", "a", false, "Approve the pull request")
-	prReviewCmd.Flags().BoolP("request-changes", "r", false, "Request changes on the pull request")
-	prReviewCmd.Flags().BoolP("comment", "c", false, "Submit as a review comment")
-	prReviewCmd.Flags().StringP("body", "b", "", "Review body/message")
-	prReviewCmd.Flags().String("body-file", "", "Read body from file (use \"-\" for stdin)")
-	addJSONFlags(prReviewCmd, "Output created review as JSON")
-}
-
-// readBody resolves the body text from --body and --body-file flags.
-// --body takes precedence; if --body-file is set and --body is empty, the file
-// (or stdin when the path is "-") is read instead.
-func readBody(cmd *cobra.Command) (string, error) {
-	body, _ := cmd.Flags().GetString("body")
-	bodyFile, _ := cmd.Flags().GetString("body-file")
-
-	if body != "" && bodyFile != "" {
-		return "", fmt.Errorf("use either --body or --body-file, not both")
-	}
-
-	if bodyFile != "" {
-		var data []byte
-		var err error
-		if bodyFile == "-" {
-			data, err = io.ReadAll(os.Stdin)
-		} else {
-			data, err = os.ReadFile(bodyFile)
-		}
-		if err != nil {
-			return "", fmt.Errorf("failed to read body file: %w", err)
-		}
-		body = string(data)
-	}
-
-	return body, nil
-}
-
-func runPRComment(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	prNumber, err := parseIssueArg(args[0])
-	if err != nil {
-		return fmt.Errorf("invalid pull request number: %w", err)
-	}
-
-	body, err := readBody(cmd)
-	if err != nil {
-		return err
-	}
-
-	if body == "" {
-		return fmt.Errorf("comment body is required (use --body or --body-file)")
-	}
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Adding comment...")
-	comment, _, err := client.CreateIssueComment(owner, name, prNumber, gitea.CreateIssueCommentOption{
-		Body: body,
-	})
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to create comment: %w", err)
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, comment)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Comment added to PR #%d\n", cs.SuccessIcon(), prNumber)
-	fmt.Fprintf(ios.Out, "View at: %s\n", comment.HTMLURL)
-
-	return nil
-}
-
-func runPRReview(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	approve, _ := cmd.Flags().GetBool("approve")
-	requestChanges, _ := cmd.Flags().GetBool("request-changes")
-	commentReview, _ := cmd.Flags().GetBool("comment")
-
-	prNumber, err := parseIssueArg(args[0])
-	if err != nil {
-		return fmt.Errorf("invalid pull request number: %w", err)
-	}
-
-	// Validate exactly one review type is specified
-	count := 0
-	if approve {
-		count++
-	}
-	if requestChanges {
-		count++
-	}
-	if commentReview {
-		count++
-	}
-	if count != 1 {
-		return fmt.Errorf("exactly one of --approve, --request-changes, or --comment must be specified")
-	}
-
-	body, err := readBody(cmd)
-	if err != nil {
-		return err
-	}
-
-	if requestChanges && body == "" {
-		return fmt.Errorf("body is required when requesting changes (use --body or --body-file)")
-	}
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	var state gitea.ReviewStateType
-	var action string
-	switch {
-	case approve:
-		state = gitea.ReviewStateApproved
-		action = "approved"
-	case requestChanges:
-		state = gitea.ReviewStateRequestChanges
-		action = "reviewed with requested changes"
-	case commentReview:
-		state = gitea.ReviewStateComment
-		action = "reviewed with comment"
-	}
-
-	ios.StartSpinner("Submitting review...")
-	review, _, err := client.CreatePullReview(owner, name, prNumber, gitea.CreatePullReviewOptions{
-		State: state,
-		Body:  body,
-	})
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to create review: %w", err)
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, review)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s PR #%d %s\n", cs.SuccessIcon(), prNumber, action)
-	if review.HTMLURL != "" {
-		fmt.Fprintf(ios.Out, "View at: %s\n", review.HTMLURL)
-	}
-
-	return nil
-}
diff --git a/cmd/release.go b/cmd/release.go
deleted file mode 100644
index 79f298e..0000000
--- a/cmd/release.go
+++ /dev/null
@@ -1,673 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"code.gitea.io/sdk/gitea"
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
-	"forgejo.zerova.net/public/fj/internal/text"
-	"github.com/spf13/cobra"
-)
-
-var releaseCmd = &cobra.Command{
-	Use:     "release",
-	Aliases: []string{"releases"},
-	Short:   "Manage releases",
-	Long:    "Create, view, list, upload assets, and delete releases.",
-}
-
-var releaseListCmd = &cobra.Command{
-	Use:   "list",
-	Short: "List releases",
-	Long:  "List releases in a repository.",
-	Example: `  # List releases
-  fj release list
-
-  # List only draft releases
-  fj release list --draft
-
-  # Output as JSON with a custom limit
-  fj release list --json --limit 10`,
-	RunE: runReleaseList,
-}
-
-var releaseViewCmd = &cobra.Command{
-	Use:   "view <tag|latest>",
-	Short: "View a release",
-	Long:  "Display detailed information about a release.",
-	Example: `  # View a release by tag
-  fj release view v1.0.0
-
-  # View the latest release
-  fj release view latest
-
-  # Open in browser
-  fj release view v1.0.0 --web
-
-  # Output as JSON
-  fj release view v1.0.0 --json`,
-	Args: cobra.ExactArgs(1),
-	RunE: runReleaseView,
-}
-
-var releaseCreateCmd = &cobra.Command{
-	Use:   "create <tag> [files...]",
-	Short: "Create a release",
-	Long:  "Create a new release and optionally upload assets.",
-	Example: `  # Create a release
-  fj release create v1.0.0
-
-  # Create with title and notes
-  fj release create v1.0.0 -t "First stable release" -n "Bug fixes and improvements"
-
-  # Create a draft prerelease with assets
-  fj release create v2.0.0-rc1 --draft --prerelease dist/*.tar.gz
-
-  # Create from release notes file
-  fj release create v1.0.0 -F CHANGELOG.md`,
-	Args: cobra.MinimumNArgs(1),
-	RunE: runReleaseCreate,
-}
-
-var releaseUploadCmd = &cobra.Command{
-	Use:   "upload <tag|latest> <files...>",
-	Short: "Upload release assets",
-	Long:  "Upload assets to an existing release.",
-	Example: `  # Upload assets to a release
-  fj release upload v1.0.0 dist/app-linux-amd64 dist/app-darwin-arm64
-
-  # Upload to the latest release, overwriting existing assets
-  fj release upload latest build/output.zip --clobber`,
-	Args: cobra.MinimumNArgs(2),
-	RunE: runReleaseUpload,
-}
-
-var releaseDownloadCmd = &cobra.Command{
-	Use:   "download <tag>",
-	Short: "Download release assets",
-	Long:  "Download assets from a release.",
-	Example: `  # Download all assets from a release
-  fj release download v1.0.0
-
-  # Download to a specific directory
-  fj release download v1.0.0 -D ./downloads
-
-  # Download a specific asset by name pattern
-  fj release download v1.0.0 -p "*.tar.gz"`,
-	Args: cobra.ExactArgs(1),
-	RunE: runReleaseDownload,
-}
-
-var releaseDeleteCmd = &cobra.Command{
-	Use:   "delete <tag|latest>",
-	Short: "Delete a release",
-	Long:  "Delete a release by tag, keeping its Git tag intact.",
-	Example: `  # Delete a release by tag
-  fj release delete v1.0.0
-
-  # Delete the latest release
-  fj release delete latest
-
-  # Delete without confirmation
-  fj release delete v1.0.0 -y`,
-	Args: cobra.ExactArgs(1),
-	RunE: runReleaseDelete,
-}
-
-func init() {
-	rootCmd.AddCommand(releaseCmd)
-	releaseCmd.AddCommand(releaseListCmd)
-	releaseCmd.AddCommand(releaseViewCmd)
-	releaseCmd.AddCommand(releaseCreateCmd)
-	releaseCmd.AddCommand(releaseUploadCmd)
-	releaseCmd.AddCommand(releaseDownloadCmd)
-	releaseCmd.AddCommand(releaseDeleteCmd)
-
-	releaseListCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	releaseListCmd.Flags().Bool("draft", false, "Filter by draft status")
-	releaseListCmd.Flags().Bool("prerelease", false, "Filter by prerelease status")
-	releaseListCmd.Flags().Int("limit", 30, "Maximum number of releases to fetch")
-	addJSONFlags(releaseListCmd, "Output releases as JSON")
-
-	releaseViewCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	addJSONFlags(releaseViewCmd, "Output release as JSON")
-	releaseViewCmd.Flags().BoolP("web", "w", false, "Open in web browser")
-
-	releaseCreateCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	releaseCreateCmd.Flags().StringP("title", "t", "", "Release title (defaults to tag)")
-	releaseCreateCmd.Flags().StringP("notes", "n", "", "Release notes")
-	releaseCreateCmd.Flags().StringP("notes-file", "F", "", "Read release notes from file")
-	releaseCreateCmd.Flags().Bool("draft", false, "Create a draft release")
-	releaseCreateCmd.Flags().Bool("prerelease", false, "Mark the release as prerelease")
-	releaseCreateCmd.Flags().String("target", "", "Target commitish (branch or SHA)")
-
-	releaseUploadCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	releaseUploadCmd.Flags().Bool("clobber", false, "Overwrite assets with the same name")
-
-	releaseDownloadCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	releaseDownloadCmd.Flags().StringP("dir", "D", ".", "Directory to download files into")
-	releaseDownloadCmd.Flags().StringP("pattern", "p", "", "Glob pattern to filter assets by name")
-
-	releaseDeleteCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	releaseDeleteCmd.Flags().BoolP("yes", "y", false, "Skip confirmation prompt")
-}
-
-func runReleaseList(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	limit, _ := cmd.Flags().GetInt("limit")
-	draftValue, _ := cmd.Flags().GetBool("draft")
-	prereleaseValue, _ := cmd.Flags().GetBool("prerelease")
-	draftSet := cmd.Flags().Changed("draft")
-	prereleaseSet := cmd.Flags().Changed("prerelease")
-
-	if limit <= 0 {
-		return fmt.Errorf("limit must be greater than 0")
-	}
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	pageSize := limit
-	if pageSize > 50 {
-		pageSize = 50
-	}
-
-	opts := gitea.ListReleasesOptions{}
-	if draftSet {
-		opts.IsDraft = &draftValue
-	}
-	if prereleaseSet {
-		opts.IsPreRelease = &prereleaseValue
-	}
-
-	ios.StartSpinner("Fetching releases...")
-	var releases []*gitea.Release
-	for page := 1; len(releases) < limit; page++ {
-		opts.ListOptions = gitea.ListOptions{Page: page, PageSize: pageSize}
-		batch, _, err := client.ListReleases(owner, name, opts)
-		if err != nil {
-			ios.StopSpinner()
-			return fmt.Errorf("failed to list releases: %w", err)
-		}
-		if len(batch) == 0 {
-			break
-		}
-		releases = append(releases, batch...)
-	}
-	ios.StopSpinner()
-
-	if len(releases) > limit {
-		releases = releases[:limit]
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, releases)
-	}
-
-	if len(releases) == 0 {
-		fmt.Fprintf(ios.Out, "No releases in %s/%s\n", owner, name)
-		return nil
-	}
-
-	isTTY := ios.IsStdoutTTY()
-	tp := ios.NewTablePrinter()
-	tp.AddHeader("TAG", "TITLE", "TYPE", "PUBLISHED")
-	for _, rel := range releases {
-		published := text.FormatDate(releaseTimestamp(rel), isTTY)
-		tp.AddRow(rel.TagName, rel.Title, releaseType(rel), published)
-	}
-	return tp.Render()
-}
-
-func runReleaseView(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	tag := args[0]
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Fetching release...")
-	release, err := getReleaseByTagOrLatest(client, owner, name, tag)
-	if err != nil {
-		ios.StopSpinner()
-		return err
-	}
-
-	attachments, err := listReleaseAttachments(client, owner, name, release.ID)
-	ios.StopSpinner()
-	if err != nil {
-		return err
-	}
-
-	if web, _ := cmd.Flags().GetBool("web"); web {
-		if release.HTMLURL != "" {
-			return ios.OpenInBrowser(release.HTMLURL)
-		}
-		return fmt.Errorf("release has no HTML URL")
-	}
-
-	if wantJSON(cmd) {
-		payload := struct {
-			Release *gitea.Release      `json:"release"`
-			Assets  []*gitea.Attachment `json:"assets,omitempty"`
-		}{
-			Release: release,
-			Assets:  attachments,
-		}
-		return outputJSON(cmd, payload)
-	}
-
-	if err := ios.StartPager(); err != nil {
-		fmt.Fprintf(ios.ErrOut, "warning: failed to start pager: %v\n", err)
-	}
-	defer ios.StopPager()
-
-	cs := ios.ColorScheme()
-	isTTY := ios.IsStdoutTTY()
-
-	fmt.Fprintf(ios.Out, "Release %s\n", cs.Bold(release.TagName))
-	fmt.Fprintf(ios.Out, "Title: %s\n", release.Title)
-	fmt.Fprintf(ios.Out, "Type: %s\n", releaseType(release))
-	if release.Target != "" {
-		fmt.Fprintf(ios.Out, "Target: %s\n", release.Target)
-	}
-	if release.Publisher != nil {
-		fmt.Fprintf(ios.Out, "Author: %s\n", release.Publisher.UserName)
-	}
-	fmt.Fprintf(ios.Out, "Created: %s\n", text.FormatDate(release.CreatedAt, isTTY))
-	if !release.PublishedAt.IsZero() {
-		fmt.Fprintf(ios.Out, "Published: %s\n", text.FormatDate(release.PublishedAt, isTTY))
-	}
-	if release.HTMLURL != "" {
-		fmt.Fprintf(ios.Out, "URL: %s\n", release.HTMLURL)
-	}
-	if release.Note != "" {
-		fmt.Fprintf(ios.Out, "\n%s\n", release.Note)
-	}
-
-	if len(attachments) > 0 {
-		fmt.Fprintf(ios.Out, "\nAssets (%d):\n", len(attachments))
-		for _, asset := range attachments {
-			fmt.Fprintf(ios.Out, "- %s (%d bytes) %s\n", asset.Name, asset.Size, asset.DownloadURL)
-		}
-	}
-
-	return nil
-}
-
-func runReleaseCreate(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	title, _ := cmd.Flags().GetString("title")
-	notes, _ := cmd.Flags().GetString("notes")
-	notesFile, _ := cmd.Flags().GetString("notes-file")
-	draft, _ := cmd.Flags().GetBool("draft")
-	prerelease, _ := cmd.Flags().GetBool("prerelease")
-	target, _ := cmd.Flags().GetString("target")
-
-	if notes != "" && notesFile != "" {
-		return fmt.Errorf("use either --notes or --notes-file, not both")
-	}
-
-	tag := args[0]
-	files := args[1:]
-
-	if notesFile != "" {
-		content, err := os.ReadFile(notesFile)
-		if err != nil {
-			return fmt.Errorf("failed to read notes file: %w", err)
-		}
-		notes = string(content)
-	}
-
-	if title == "" {
-		title = tag
-	}
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Creating release...")
-	release, _, err := client.CreateRelease(owner, name, gitea.CreateReleaseOption{
-		TagName:      tag,
-		Target:       target,
-		Title:        title,
-		Note:         notes,
-		IsDraft:      draft,
-		IsPrerelease: prerelease,
-	})
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to create release: %w", err)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Release created: %s\n", cs.SuccessIcon(), release.TagName)
-	if release.HTMLURL != "" {
-		fmt.Fprintf(ios.Out, "View at: %s\n", release.HTMLURL)
-	}
-
-	if len(files) == 0 {
-		return nil
-	}
-
-	ios.StartSpinner("Uploading assets...")
-	if err := uploadReleaseAssets(client, owner, name, release.ID, files, false); err != nil {
-		ios.StopSpinner()
-		return err
-	}
-	ios.StopSpinner()
-
-	fmt.Fprintf(ios.Out, "%s Uploaded %s\n", cs.SuccessIcon(), text.Pluralize(len(files), "asset"))
-	return nil
-}
-
-func runReleaseUpload(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	clobber, _ := cmd.Flags().GetBool("clobber")
-
-	tag := args[0]
-	files := args[1:]
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Fetching release...")
-	release, err := getReleaseByTagOrLatest(client, owner, name, tag)
-	ios.StopSpinner()
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Uploading assets...")
-	if err := uploadReleaseAssets(client, owner, name, release.ID, files, clobber); err != nil {
-		ios.StopSpinner()
-		return err
-	}
-	ios.StopSpinner()
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Uploaded %s\n", cs.SuccessIcon(), text.Pluralize(len(files), "asset"))
-	return nil
-}
-
-func runReleaseDownload(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	dir, _ := cmd.Flags().GetString("dir")
-	pattern, _ := cmd.Flags().GetString("pattern")
-	tag := args[0]
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Fetching release...")
-	release, err := getReleaseByTagOrLatest(client, owner, name, tag)
-	if err != nil {
-		ios.StopSpinner()
-		return err
-	}
-
-	attachments, err := listReleaseAttachments(client, owner, name, release.ID)
-	ios.StopSpinner()
-	if err != nil {
-		return err
-	}
-
-	if len(attachments) == 0 {
-		fmt.Fprintf(ios.Out, "No assets found for release %s\n", release.TagName)
-		return nil
-	}
-
-	// Filter by pattern if provided
-	var toDownload []*gitea.Attachment
-	for _, a := range attachments {
-		if pattern != "" {
-			matched, matchErr := path.Match(pattern, a.Name)
-			if matchErr != nil {
-				return fmt.Errorf("invalid glob pattern %q: %w", pattern, matchErr)
-			}
-			if !matched {
-				continue
-			}
-		}
-		toDownload = append(toDownload, a)
-	}
-
-	if len(toDownload) == 0 {
-		fmt.Fprintf(ios.Out, "No assets matching pattern %q in release %s\n", pattern, release.TagName)
-		return nil
-	}
-
-	// Ensure download directory exists
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		return fmt.Errorf("failed to create directory %s: %w", dir, err)
-	}
-
-	for _, a := range toDownload {
-		destPath := filepath.Join(dir, a.Name)
-		f, createErr := os.Create(destPath)
-		if createErr != nil {
-			return fmt.Errorf("failed to create file %s: %w", destPath, createErr)
-		}
-
-		dlErr := client.DownloadFile(a.DownloadURL, f)
-		closeErr := f.Close()
-		if dlErr != nil {
-			return fmt.Errorf("failed to download %s: %w", a.Name, dlErr)
-		}
-		if closeErr != nil {
-			return fmt.Errorf("failed to close %s: %w", destPath, closeErr)
-		}
-
-		fmt.Fprintf(ios.Out, "Downloaded %s (%d bytes)\n", a.Name, a.Size)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "\n%s %s downloaded to %s\n", cs.SuccessIcon(), text.Pluralize(len(toDownload), "asset"), dir)
-	return nil
-}
-
-func runReleaseDelete(cmd *cobra.Command, args []string) error {
-	repo, _ := cmd.Flags().GetString("repo")
-	yes, _ := cmd.Flags().GetBool("yes")
-	tag := args[0]
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	ios.StartSpinner("Fetching release...")
-	release, err := getReleaseByTagOrLatest(client, owner, name, tag)
-	ios.StopSpinner()
-	if err != nil {
-		return err
-	}
-
-	if !yes {
-		confirmed, err := ios.ConfirmAction(fmt.Sprintf("Delete release %s?", release.TagName))
-		if err != nil {
-			return err
-		}
-		if !confirmed {
-			fmt.Fprintln(ios.ErrOut, "Aborted")
-			return nil
-		}
-	}
-
-	ios.StartSpinner("Deleting release...")
-	if _, err := client.DeleteRelease(owner, name, release.ID); err != nil {
-		ios.StopSpinner()
-		return fmt.Errorf("failed to delete release: %w", err)
-	}
-	ios.StopSpinner()
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Release %s deleted\n", cs.SuccessIcon(), release.TagName)
-	return nil
-}
-
-func getReleaseByTagOrLatest(client *api.Client, owner, name, tag string) (*gitea.Release, error) {
-	if strings.EqualFold(tag, "latest") {
-		release, _, err := client.GetLatestRelease(owner, name)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get latest release: %w", err)
-		}
-		return release, nil
-	}
-
-	release, _, err := client.GetReleaseByTag(owner, name, tag)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get release: %w", err)
-	}
-	return release, nil
-}
-
-func uploadReleaseAssets(client *api.Client, owner, name string, releaseID int64, files []string, clobber bool) error {
-	existing := map[string]int64{}
-	if clobber {
-		attachments, err := listReleaseAttachments(client, owner, name, releaseID)
-		if err != nil {
-			return err
-		}
-		for _, attachment := range attachments {
-			existing[attachment.Name] = attachment.ID
-		}
-	}
-
-	for _, file := range files {
-		filename := filepath.Base(file)
-		if clobber {
-			if attachmentID, ok := existing[filename]; ok {
-				if _, err := client.DeleteReleaseAttachment(owner, name, releaseID, attachmentID); err != nil {
-					return fmt.Errorf("failed to delete existing asset %s: %w", filename, err)
-				}
-			}
-		}
-
-		handle, err := os.Open(file)
-		if err != nil {
-			return fmt.Errorf("failed to open %s: %w", file, err)
-		}
-
-		_, _, err = client.CreateReleaseAttachment(owner, name, releaseID, handle, filename)
-		closeErr := handle.Close()
-		if err != nil {
-			return fmt.Errorf("failed to upload %s: %w", file, err)
-		}
-		if closeErr != nil {
-			return fmt.Errorf("failed to close %s: %w", file, closeErr)
-		}
-	}
-
-	return nil
-}
-
-func listReleaseAttachments(client *api.Client, owner, name string, releaseID int64) ([]*gitea.Attachment, error) {
-	var all []*gitea.Attachment
-	for page := 1; ; page++ {
-		attachments, _, err := client.ListReleaseAttachments(owner, name, releaseID, gitea.ListReleaseAttachmentsOptions{
-			ListOptions: gitea.ListOptions{Page: page, PageSize: 50},
-		})
-		if err != nil {
-			return nil, fmt.Errorf("failed to list release assets: %w", err)
-		}
-		if len(attachments) == 0 {
-			break
-		}
-		all = append(all, attachments...)
-	}
-	return all, nil
-}
-
-func releaseType(release *gitea.Release) string {
-	if release.IsDraft {
-		return "draft"
-	}
-	if release.IsPrerelease {
-		return "prerelease"
-	}
-	return "release"
-}
-
-func releaseTimestamp(release *gitea.Release) time.Time {
-	if !release.PublishedAt.IsZero() {
-		return release.PublishedAt
-	}
-	return release.CreatedAt
-}
diff --git a/cmd/repo.go b/cmd/repo.go
index 0514c4d..41f6650 100644
--- a/cmd/repo.go
+++ b/cmd/repo.go
@@ -5,13 +5,12 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"strings"
+	"text/tabwriter"
 
 	"code.gitea.io/sdk/gitea"
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
-	"forgejo.zerova.net/public/fj/internal/text"
 	"github.com/spf13/cobra"
+	"codeberg.org/romaintb/fgj/internal/api"
+	"codeberg.org/romaintb/fgj/internal/config"
 )
 
 var repoCmd = &cobra.Command{
@@ -51,96 +50,14 @@ var repoForkCmd = &cobra.Command{
 	RunE:  runRepoFork,
 }
 
-var repoCreateCmd = &cobra.Command{
-	Use:   "create <name>",
-	Short: "Create a new repository",
-	Long: `Create a new repository on the Forgejo instance.
-
-Name can be "reponame" (creates under your account) or "org/reponame"
-(creates under an organization). Repositories are public by default; use --private to create a private one.`,
-	Args: cobra.ExactArgs(1),
-	RunE: runRepoCreate,
-}
-
-var repoEditCmd = &cobra.Command{
-	Use:   "edit [owner/name]",
-	Short: "Edit repository settings",
-	Long:  "Edit settings of an existing repository such as visibility, description, homepage, and default branch.",
-	Example: `  # Make a repository private
-  fj repo edit owner/repo --private
-
-  # Make a repository public
-  fj repo edit owner/repo --public
-
-  # Update description and homepage
-  fj repo edit owner/repo -d "New description" --homepage https://example.com
-
-  # Change default branch
-  fj repo edit --default-branch develop
-
-  # Rename a repository
-  fj repo edit owner/repo --name new-name
-
-  # Edit current repo (auto-detected from git context)
-  fj repo edit --public`,
-	Args: cobra.MaximumNArgs(1),
-	RunE: runRepoEdit,
-}
-
-var repoRenameCmd = &cobra.Command{
-	Use:   "rename <new-name>",
-	Short: "Rename a repository",
-	Long:  "Rename an existing repository. This is a shorthand for `fj repo edit --name <new-name>`.",
-	Example: `  # Rename current repo
-  fj repo rename new-name
-
-  # Rename a specific repo
-  fj repo rename new-name -R owner/old-name`,
-	Args: cobra.ExactArgs(1),
-	RunE: runRepoRename,
-}
-
 func init() {
 	rootCmd.AddCommand(repoCmd)
-	repoCmd.AddCommand(repoCloneCmd)
-	repoCmd.AddCommand(repoCreateCmd)
-	repoCmd.AddCommand(repoEditCmd)
-	repoCmd.AddCommand(repoRenameCmd)
-	repoCmd.AddCommand(repoForkCmd)
-	repoCmd.AddCommand(repoListCmd)
 	repoCmd.AddCommand(repoViewCmd)
-
-	repoCreateCmd.Flags().StringP("description", "d", "", "Description of the repository")
-	repoCreateCmd.Flags().Bool("private", false, "Make the new repository private")
-	repoCreateCmd.Flags().Bool("public", false, "Make the new repository public")
-	repoCreateCmd.Flags().Bool("add-readme", false, "Add a README file to the new repository")
-	repoCreateCmd.Flags().StringP("gitignore", "g", "", "Gitignore template (e.g. Go, Python)")
-	repoCreateCmd.Flags().StringP("license", "l", "", "License template (e.g. MIT, Apache-2.0)")
-	repoCreateCmd.Flags().String("homepage", "", "Repository home page URL")
-	repoCreateCmd.Flags().BoolP("clone", "c", false, "Clone the new repository to the current directory")
-	repoCreateCmd.Flags().StringP("team", "t", "", "Team name to be granted access (org repos only)")
-	repoCreateCmd.MarkFlagsMutuallyExclusive("public", "private")
-
-	addJSONFlags(repoViewCmd, "Output repository as JSON")
-	repoViewCmd.Flags().BoolP("web", "w", false, "Open in web browser")
-
-	addJSONFlags(repoListCmd, "Output repositories as JSON")
-	repoListCmd.Flags().IntP("limit", "L", 0, "Maximum number of repositories to list (0 = no limit)")
+	repoCmd.AddCommand(repoListCmd)
+	repoCmd.AddCommand(repoCloneCmd)
+	repoCmd.AddCommand(repoForkCmd)
 
 	repoCloneCmd.Flags().StringP("protocol", "p", "https", "Clone protocol: https or ssh")
-
-	repoEditCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	repoEditCmd.Flags().String("name", "", "Rename the repository")
-	repoEditCmd.Flags().StringP("description", "d", "", "Repository description")
-	repoEditCmd.Flags().String("homepage", "", "Repository home page URL")
-	repoEditCmd.Flags().String("default-branch", "", "Default branch name")
-	repoEditCmd.Flags().Bool("private", false, "Make the repository private")
-	repoEditCmd.Flags().Bool("public", false, "Make the repository public")
-	addJSONFlags(repoEditCmd, "Output updated repository as JSON")
-	repoEditCmd.MarkFlagsMutuallyExclusive("public", "private")
-
-	repoRenameCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	addJSONFlags(repoRenameCmd, "Output updated repository as JSON")
 }
 
 func runRepoView(cmd *cobra.Command, args []string) error {
@@ -159,41 +76,28 @@ func runRepoView(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return err
 	}
 
-	ios.StartSpinner("Fetching repository...")
 	repository, _, err := client.GetRepo(owner, name)
-	ios.StopSpinner()
 	if err != nil {
 		return fmt.Errorf("failed to get repository: %w", err)
 	}
 
-	if web, _ := cmd.Flags().GetBool("web"); web {
-		return ios.OpenInBrowser(repository.HTMLURL)
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, repository)
-	}
-
-	cs := ios.ColorScheme()
-	isTTY := ios.IsStdoutTTY()
-
-	fmt.Fprintf(ios.Out, "Repository: %s\n", cs.Bold(fmt.Sprintf("%s/%s", repository.Owner.UserName, repository.Name)))
-	fmt.Fprintf(ios.Out, "Description: %s\n", repository.Description)
-	fmt.Fprintf(ios.Out, "URL: %s\n", repository.HTMLURL)
-	fmt.Fprintf(ios.Out, "Clone URL (HTTPS): %s\n", repository.CloneURL)
-	fmt.Fprintf(ios.Out, "Clone URL (SSH): %s\n", repository.SSHURL)
-	fmt.Fprintf(ios.Out, "Default Branch: %s\n", repository.DefaultBranch)
-	fmt.Fprintf(ios.Out, "Stars: %d\n", repository.Stars)
-	fmt.Fprintf(ios.Out, "Forks: %d\n", repository.Forks)
-	fmt.Fprintf(ios.Out, "Open Issues: %d\n", repository.OpenIssues)
-	fmt.Fprintf(ios.Out, "Private: %v\n", repository.Private)
-	fmt.Fprintf(ios.Out, "Created: %s\n", text.FormatDate(repository.Created, isTTY))
-	fmt.Fprintf(ios.Out, "Updated: %s\n", text.FormatDate(repository.Updated, isTTY))
+	fmt.Printf("Repository: %s/%s\n", repository.Owner.UserName, repository.Name)
+	fmt.Printf("Description: %s\n", repository.Description)
+	fmt.Printf("URL: %s\n", repository.HTMLURL)
+	fmt.Printf("Clone URL (HTTPS): %s\n", repository.CloneURL)
+	fmt.Printf("Clone URL (SSH): %s\n", repository.SSHURL)
+	fmt.Printf("Default Branch: %s\n", repository.DefaultBranch)
+	fmt.Printf("Stars: %d\n", repository.Stars)
+	fmt.Printf("Forks: %d\n", repository.Forks)
+	fmt.Printf("Open Issues: %d\n", repository.OpenIssues)
+	fmt.Printf("Private: %v\n", repository.Private)
+	fmt.Printf("Created: %s\n", repository.Created.Format("2006-01-02 15:04:05"))
+	fmt.Printf("Updated: %s\n", repository.Updated.Format("2006-01-02 15:04:05"))
 
 	return nil
 }
@@ -204,50 +108,42 @@ func runRepoList(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return err
 	}
 
-	ios.StartSpinner("Fetching repositories...")
 	user, _, err := client.GetMyUserInfo()
 	if err != nil {
-		ios.StopSpinner()
 		return fmt.Errorf("failed to get user info: %w", err)
 	}
 
-	limit, _ := cmd.Flags().GetInt("limit")
-	repos, err := paginateGitea(limit, func(page, pageSize int) ([]*gitea.Repository, error) {
-		batch, _, err := client.ListUserRepos(user.UserName, gitea.ListReposOptions{
-			ListOptions: gitea.ListOptions{Page: page, PageSize: pageSize},
-		})
-		return batch, err
-	})
-	ios.StopSpinner()
+	repos, _, err := client.ListUserRepos(user.UserName, gitea.ListReposOptions{})
 	if err != nil {
 		return fmt.Errorf("failed to list repositories: %w", err)
 	}
 
-	if wantJSON(cmd) {
-		return outputJSON(cmd, repos)
-	}
-
 	if len(repos) == 0 {
-		fmt.Fprintln(ios.Out, "No repositories found")
+		fmt.Println("No repositories found")
 		return nil
 	}
 
-	tp := ios.NewTablePrinter()
-	tp.AddHeader("NAME", "VISIBILITY", "DESCRIPTION")
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+	_, _ = fmt.Fprintf(w, "NAME\tVISIBILITY\tDESCRIPTION\n")
 	for _, repo := range repos {
 		visibility := "public"
 		if repo.Private {
 			visibility = "private"
 		}
-		desc := text.Truncate(repo.Description, 50)
-		tp.AddRow(fmt.Sprintf("%s/%s", repo.Owner.UserName, repo.Name), visibility, desc)
+		desc := repo.Description
+		if len(desc) > 50 {
+			desc = desc[:47] + "..."
+		}
+		_, _ = fmt.Fprintf(w, "%s/%s\t%s\t%s\n", repo.Owner.UserName, repo.Name, visibility, desc)
 	}
-	return tp.Render()
+	_ = w.Flush()
+
+	return nil
 }
 
 func runRepoClone(cmd *cobra.Command, args []string) error {
@@ -264,14 +160,12 @@ func runRepoClone(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return err
 	}
 
-	ios.StartSpinner("Fetching repository info...")
 	repository, _, err := client.GetRepo(owner, name)
-	ios.StopSpinner()
 	if err != nil {
 		return fmt.Errorf("failed to get repository: %w", err)
 	}
@@ -291,7 +185,7 @@ func runRepoClone(cmd *cobra.Command, args []string) error {
 		destination = name
 	}
 
-	fmt.Fprintf(ios.Out, "Cloning %s/%s to %s...\n", owner, name, destination)
+	fmt.Printf("Cloning %s/%s to %s...\n", owner, name, destination)
 
 	// Create parent directory if it doesn't exist
 	if dir := filepath.Dir(destination); dir != "." {
@@ -300,21 +194,17 @@ func runRepoClone(cmd *cobra.Command, args []string) error {
 		}
 	}
 
-	ios.StartSpinner("Cloning repository...")
 	// Execute git clone
 	gitCmd := exec.Command("git", "clone", cloneURL, destination)
-	gitCmd.Stdout = ios.Out
-	gitCmd.Stderr = ios.ErrOut
-	gitCmd.Stdin = ios.In
+	gitCmd.Stdout = os.Stdout
+	gitCmd.Stderr = os.Stderr
+	gitCmd.Stdin = os.Stdin
 
 	if err := gitCmd.Run(); err != nil {
-		ios.StopSpinner()
 		return fmt.Errorf("failed to clone repository: %w", err)
 	}
-	ios.StopSpinner()
 
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Repository cloned successfully to %s\n", cs.SuccessIcon(), destination)
+	fmt.Printf("Repository cloned successfully to %s\n", destination)
 	return nil
 }
 
@@ -331,294 +221,19 @@ func runRepoFork(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	client, err := api.NewClientFromConfig(cfg, "")
 	if err != nil {
 		return err
 	}
 
-	ios.StartSpinner("Forking repository...")
 	fork, _, err := client.CreateFork(owner, name, gitea.CreateForkOption{})
-	ios.StopSpinner()
 	if err != nil {
 		return fmt.Errorf("failed to fork repository: %w", err)
 	}
 
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Repository forked successfully\n", cs.SuccessIcon())
-	fmt.Fprintf(ios.Out, "View at: %s\n", fork.HTMLURL)
-	fmt.Fprintf(ios.Out, "Clone URL: %s\n", fork.CloneURL)
+	fmt.Printf("Repository forked successfully\n")
+	fmt.Printf("View at: %s\n", fork.HTMLURL)
+	fmt.Printf("Clone URL: %s\n", fork.CloneURL)
 
 	return nil
 }
-
-func runRepoCreate(cmd *cobra.Command, args []string) error {
-	inputName := args[0]
-	org, repoName, isOrg, err := parseCreateName(inputName)
-	if err != nil {
-		return err
-	}
-
-	private, _ := cmd.Flags().GetBool("private")
-	public, _ := cmd.Flags().GetBool("public")
-	description, _ := cmd.Flags().GetString("description")
-	addReadme, _ := cmd.Flags().GetBool("add-readme")
-	gitignore, _ := cmd.Flags().GetString("gitignore")
-	license, _ := cmd.Flags().GetString("license")
-	homepage, _ := cmd.Flags().GetString("homepage")
-	doClone, _ := cmd.Flags().GetBool("clone")
-	team, _ := cmd.Flags().GetString("team")
-
-	// --public explicitly sets private=false (default behavior, but makes intent clear)
-	if public {
-		private = false
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	opt := gitea.CreateRepoOption{
-		Name:        repoName,
-		Description: description,
-		Private:     private,
-		AutoInit:    addReadme,
-		Gitignores:  gitignore,
-		License:     license,
-	}
-
-	ios.StartSpinner("Creating repository...")
-	var repo *gitea.Repository
-	if isOrg {
-		repo, _, err = client.CreateOrgRepo(org, opt)
-	} else {
-		repo, _, err = client.CreateRepo(opt)
-	}
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to create repository: %w", err)
-	}
-
-	if homepage != "" {
-		ownerName := org
-		if !isOrg {
-			// For personal repos, get the owner from the created repo or fall back to API
-			if repo.Owner != nil {
-				ownerName = repo.Owner.UserName
-			} else {
-				user, _, userErr := client.GetMyUserInfo()
-				if userErr != nil {
-					fmt.Fprintf(ios.ErrOut, "warning: repository created but could not determine owner for homepage: %v\n", userErr)
-					homepage = "" // skip EditRepo
-				} else {
-					ownerName = user.UserName
-				}
-			}
-		}
-		if homepage != "" {
-			_, _, err = client.EditRepo(ownerName, repo.Name, gitea.EditRepoOption{
-				Website: &homepage,
-			})
-			if err != nil {
-				fmt.Fprintf(ios.ErrOut, "warning: repository created but failed to set homepage: %v\n", err)
-			}
-		}
-	}
-
-	if team != "" {
-		if !isOrg {
-			fmt.Fprintln(ios.ErrOut, "warning: --team is only meaningful for organization repositories")
-		} else {
-			_, err = client.AddRepoTeam(org, repo.Name, team)
-			if err != nil {
-				fmt.Fprintf(ios.ErrOut, "warning: repository created but failed to add team %q: %v\n", team, err)
-			}
-		}
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Repository created: %s\n", cs.SuccessIcon(), repo.HTMLURL)
-
-	if doClone {
-		cloneURL := repo.CloneURL
-		if hostCfg, hostErr := cfg.GetHost("", getDetectedHost(), getCwd()); hostErr == nil {
-			if hostCfg.GitProtocol == "ssh" {
-				cloneURL = repo.SSHURL
-			}
-		}
-		fmt.Fprintf(ios.Out, "Cloning into %s...\n", repo.Name)
-		gitCmd := exec.Command("git", "clone", cloneURL, repo.Name)
-		gitCmd.Stdout = ios.Out
-		gitCmd.Stderr = ios.ErrOut
-		gitCmd.Stdin = ios.In
-		if err := gitCmd.Run(); err != nil {
-			return fmt.Errorf("failed to clone repository: %w", err)
-		}
-	}
-
-	return nil
-}
-
-// parseCreateName parses the name argument for repo creation.
-// Returns org, repoName, and whether it targets an org.
-// Input: "reponame" → ("", "reponame", false)
-// Input: "org/reponame" → ("org", "reponame", true)
-func parseCreateName(name string) (org, repoName string, isOrg bool, err error) {
-	parts := strings.SplitN(name, "/", 2)
-	if len(parts) == 2 {
-		if parts[0] == "" || parts[1] == "" {
-			return "", "", false, fmt.Errorf("invalid repository name %q: org and repo name must not be empty", name)
-		}
-		return parts[0], parts[1], true, nil
-	}
-	if name == "" {
-		return "", "", false, fmt.Errorf("repository name must not be empty")
-	}
-	return "", name, false, nil
-}
-
-func runRepoEdit(cmd *cobra.Command, args []string) error {
-	var repo string
-	if len(args) > 0 {
-		repo = args[0]
-	}
-	if r, _ := cmd.Flags().GetString("repo"); r != "" {
-		repo = r
-	}
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	opt := gitea.EditRepoOption{}
-	changed := false
-
-	if cmd.Flags().Changed("name") {
-		n, _ := cmd.Flags().GetString("name")
-		opt.Name = &n
-		changed = true
-	}
-	if cmd.Flags().Changed("description") {
-		d, _ := cmd.Flags().GetString("description")
-		opt.Description = &d
-		changed = true
-	}
-	if cmd.Flags().Changed("homepage") {
-		h, _ := cmd.Flags().GetString("homepage")
-		opt.Website = &h
-		changed = true
-	}
-	if cmd.Flags().Changed("default-branch") {
-		b, _ := cmd.Flags().GetString("default-branch")
-		opt.DefaultBranch = &b
-		changed = true
-	}
-	if cmd.Flags().Changed("private") {
-		p := true
-		opt.Private = &p
-		changed = true
-	}
-	if cmd.Flags().Changed("public") {
-		p := false
-		opt.Private = &p
-		changed = true
-	}
-
-	if !changed {
-		return fmt.Errorf("no changes specified; use flags like --name, --public, --private, --description, --homepage, or --default-branch")
-	}
-
-	ios.StartSpinner("Updating repository...")
-	repository, _, err := client.EditRepo(owner, name, opt)
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to edit repository: %w", err)
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, repository)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Repository updated: %s\n", cs.SuccessIcon(), repository.HTMLURL)
-	if opt.Name != nil {
-		fmt.Fprintf(ios.Out, "Renamed to: %s\n", repository.FullName)
-	}
-	if opt.Private != nil {
-		if *opt.Private {
-			fmt.Fprintln(ios.Out, "Visibility: private")
-		} else {
-			fmt.Fprintln(ios.Out, "Visibility: public")
-		}
-	}
-	if opt.Description != nil {
-		fmt.Fprintf(ios.Out, "Description: %s\n", *opt.Description)
-	}
-	if opt.Website != nil {
-		fmt.Fprintf(ios.Out, "Homepage: %s\n", *opt.Website)
-	}
-	if opt.DefaultBranch != nil {
-		fmt.Fprintf(ios.Out, "Default branch: %s\n", *opt.DefaultBranch)
-	}
-
-	return nil
-}
-
-func runRepoRename(cmd *cobra.Command, args []string) error {
-	var repo string
-	if r, _ := cmd.Flags().GetString("repo"); r != "" {
-		repo = r
-	}
-
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return err
-	}
-
-	newName := args[0]
-
-	cfg, err := config.Load()
-	if err != nil {
-		return err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return err
-	}
-
-	opt := gitea.EditRepoOption{
-		Name: &newName,
-	}
-
-	ios.StartSpinner("Renaming repository...")
-	repository, _, err := client.EditRepo(owner, name, opt)
-	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to rename repository: %w", err)
-	}
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, repository)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Renamed %s/%s to %s\n", cs.SuccessIcon(), owner, name, repository.FullName)
-	return nil
-}
diff --git a/cmd/repo_create_test.go b/cmd/repo_create_test.go
deleted file mode 100644
index 6405553..0000000
--- a/cmd/repo_create_test.go
+++ /dev/null
@@ -1,53 +0,0 @@
-package cmd
-
-import "testing"
-
-func TestParseCreateName(t *testing.T) {
-	t.Run("simple repo name", func(t *testing.T) {
-		org, repo, isOrg, err := parseCreateName("myrepo")
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if org != "" || repo != "myrepo" || isOrg {
-			t.Errorf("got (%q, %q, %v), want (%q, %q, %v)", org, repo, isOrg, "", "myrepo", false)
-		}
-	})
-
-	t.Run("org/repo name", func(t *testing.T) {
-		org, repo, isOrg, err := parseCreateName("myorg/myrepo")
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if org != "myorg" || repo != "myrepo" || !isOrg {
-			t.Errorf("got (%q, %q, %v), want (%q, %q, %v)", org, repo, isOrg, "myorg", "myrepo", true)
-		}
-	})
-
-	t.Run("empty string", func(t *testing.T) {
-		_, _, _, err := parseCreateName("")
-		if err == nil {
-			t.Error("expected error for empty string, got nil")
-		}
-	})
-
-	t.Run("slash only", func(t *testing.T) {
-		_, _, _, err := parseCreateName("/")
-		if err == nil {
-			t.Error("expected error for '/', got nil")
-		}
-	})
-
-	t.Run("empty repo after slash", func(t *testing.T) {
-		_, _, _, err := parseCreateName("org/")
-		if err == nil {
-			t.Error("expected error for 'org/', got nil")
-		}
-	})
-
-	t.Run("empty org before slash", func(t *testing.T) {
-		_, _, _, err := parseCreateName("/repo")
-		if err == nil {
-			t.Error("expected error for '/repo', got nil")
-		}
-	})
-}
diff --git a/cmd/root.go b/cmd/root.go
index 8b4dcef..34fef9c 100644
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -2,33 +2,20 @@ package cmd
 
 import (
 	"fmt"
-	"io"
 	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
 
-	"forgejo.zerova.net/public/fj/internal/config"
-	"forgejo.zerova.net/public/fj/internal/git"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
 
 var cfgFile string
-var jsonErrors bool
 
 var rootCmd = &cobra.Command{
-	Use:   "fj",
+	Use:   "fgj",
 	Short: "Forgejo CLI tool - work seamlessly with Forgejo from the command line",
-	Long: `fj is a command line tool for Forgejo instances (including Codeberg).
+	Long: `fgj is a command line tool for Forgejo instances (including Codeberg).
 It brings pull requests, issues, and other Forgejo concepts to the terminal.`,
-	Version:       "0.4.0",
-	SilenceErrors: true,
-}
-
-// JSONErrors reports whether the --json-errors flag is set.
-func JSONErrors() bool {
-	return jsonErrors
+	Version: "0.1.0",
 }
 
 func Execute() error {
@@ -38,41 +25,23 @@ func Execute() error {
 func init() {
 	cobra.OnInitialize(initConfig)
 
-	rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.config/fj/config.yaml)")
-	rootCmd.PersistentFlags().BoolVar(&jsonErrors, "json-errors", false, "output errors as structured JSON to stderr")
+	rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.config/fgj/config.yaml)")
 	rootCmd.PersistentFlags().String("hostname", "", "Forgejo instance hostname")
 	_ = viper.BindPFlag("hostname", rootCmd.PersistentFlags().Lookup("hostname"))
 }
 
 func initConfig() {
 	if cfgFile != "" {
-		// Tell viper to load this file for env-style overrides AND make
-		// internal/config.Load()/.Save() use it (this is the load-bearing
-		// half — without SetExplicitConfigPath, --config was silently
-		// ignored by every auth-touching command).
 		viper.SetConfigFile(cfgFile)
-		config.SetExplicitConfigPath(cfgFile)
 	} else {
 		home, err := os.UserHomeDir()
 		if err != nil {
-			fmt.Fprintln(ios.ErrOut, err)
+			fmt.Fprintln(os.Stderr, err)
 			os.Exit(1)
 		}
 
-		configDir := home + "/.config/fj"
-		legacyDir := home + "/.config/fgj"
-
-		// Migrate from ~/.config/fgj/ if the new dir doesn't exist yet.
-		if _, err := os.Stat(configDir); os.IsNotExist(err) {
-			if info, err := os.Stat(legacyDir); err == nil && info.IsDir() {
-				if copyErr := migrateConfigDir(legacyDir, configDir); copyErr == nil {
-					fmt.Fprintln(ios.ErrOut, "notice: migrated config from ~/.config/fgj/ to ~/.config/fj/")
-					fmt.Fprintln(ios.ErrOut, "        you can remove ~/.config/fgj/ when ready")
-				}
-			}
-		}
-
-		_ = os.MkdirAll(configDir, 0700)
+		configDir := home + "/.config/fgj"
+		_ = os.MkdirAll(configDir, 0755)
 
 		viper.AddConfigPath(configDir)
 		viper.SetConfigType("yaml")
@@ -80,126 +49,7 @@ func initConfig() {
 	}
 
 	viper.AutomaticEnv()
-	viper.SetEnvPrefix("FJ")
+	viper.SetEnvPrefix("FGJ")
 
 	_ = viper.ReadInConfig()
-
-	// If the resolved config exists with overly permissive mode, warn — the
-	// file holds API tokens. Don't fail-close; just nudge the user.
-	if path, err := config.GetConfigPath(); err == nil {
-		if info, statErr := os.Stat(path); statErr == nil && info.Mode()&0o077 != 0 {
-			fmt.Fprintf(ios.ErrOut, "warning: %s mode %o is world/group readable; tokens may leak. chmod 600 it.\n", path, info.Mode().Perm())
-		}
-	}
-}
-
-// parseRepo parses the repository string in the format "owner/name".
-// If not provided, it attempts to auto-detect from the git repository.
-func parseRepo(repo string) (string, string, error) {
-	// If repo flag is provided, use it
-	if repo != "" {
-		parts := strings.Split(repo, "/")
-		if len(parts) != 2 {
-			return "", "", fmt.Errorf("invalid repository format: %s (expected: owner/name)", repo)
-		}
-		return parts[0], parts[1], nil
-	}
-
-	// Try to auto-detect from git
-	owner, name, err := git.DetectRepo()
-	if err != nil {
-		return "", "", fmt.Errorf("repository flag is required (use -R owner/name) or run from a git repository: %w", err)
-	}
-
-	return owner, name, nil
-}
-
-// getDetectedHost attempts to auto-detect the Forgejo instance hostname.
-// Returns empty string if detection fails, which will fall back to other methods.
-func getDetectedHost() string {
-	host, err := git.DetectHost()
-	if err != nil {
-		return ""
-	}
-	return host
-}
-
-// getCwd returns the current working directory, or "" on error.
-func getCwd() string {
-	cwd, err := os.Getwd()
-	if err != nil {
-		return ""
-	}
-	return cwd
-}
-
-// promptLine prints a prompt to stderr and reads a line from stdin.
-func promptLine(prompt string) (string, error) {
-	fmt.Fprint(ios.ErrOut, prompt)
-	var buf [1024]byte
-	n, err := ios.In.Read(buf[:])
-	if err != nil {
-		return "", fmt.Errorf("reading input: %w", err)
-	}
-	return strings.TrimSpace(string(buf[:n])), nil
-}
-
-// parseIssueArg parses an issue/PR number from various formats:
-// "123", "#123", "https://host/owner/repo/pulls/123", "https://host/owner/repo/issues/123"
-func parseIssueArg(arg string) (int64, error) {
-	arg = strings.TrimPrefix(arg, "#")
-	// Try URL format
-	if strings.HasPrefix(arg, "http") {
-		parts := strings.Split(strings.TrimRight(arg, "/"), "/")
-		arg = parts[len(parts)-1]
-	}
-	return strconv.ParseInt(arg, 10, 64)
-}
-
-// migrateConfigDir copies all files from src to dst (one level, no subdirs).
-// Uses O_TRUNC so a partially-pre-existing dst file is fully replaced rather
-// than having the legacy contents overwrite a prefix and leaving stale tail
-// bytes — which for a YAML token store would silently corrupt config.
-func migrateConfigDir(src, dst string) error {
-	if err := os.MkdirAll(dst, 0700); err != nil {
-		return err
-	}
-	entries, err := os.ReadDir(src)
-	if err != nil {
-		return err
-	}
-	for _, e := range entries {
-		if e.IsDir() {
-			continue
-		}
-		if err := copyOneConfigFile(filepath.Join(src, e.Name()), filepath.Join(dst, e.Name())); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func copyOneConfigFile(srcPath, dstPath string) (retErr error) {
-	in, err := os.Open(srcPath)
-	if err != nil {
-		return err
-	}
-	defer func() {
-		if cerr := in.Close(); retErr == nil {
-			retErr = cerr
-		}
-	}()
-
-	out, err := os.OpenFile(dstPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0600)
-	if err != nil {
-		return err
-	}
-	defer func() {
-		if cerr := out.Close(); retErr == nil {
-			retErr = cerr
-		}
-	}()
-
-	_, err = io.Copy(out, in)
-	return err
 }
diff --git a/cmd/wiki.go b/cmd/wiki.go
deleted file mode 100644
index 63cb504..0000000
--- a/cmd/wiki.go
+++ /dev/null
@@ -1,404 +0,0 @@
-package cmd
-
-import (
-	"encoding/base64"
-	"fmt"
-	"net/http"
-	"net/url"
-	"time"
-
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
-	"forgejo.zerova.net/public/fj/internal/text"
-	"github.com/spf13/cobra"
-)
-
-// Wiki API response types
-
-type wikiPageMeta struct {
-	Title      string      `json:"title"`
-	HTMLURL    string      `json:"html_url"`
-	SubURL     string      `json:"sub_url"`
-	LastCommit *wikiCommit `json:"last_commit"`
-}
-
-type wikiCommit struct {
-	ID        string    `json:"id"`
-	Author    *wikiUser `json:"author"`
-	Committer *wikiUser `json:"committer"`
-	Message   string    `json:"message"`
-}
-
-type wikiUser struct {
-	Name  string `json:"name"`
-	Email string `json:"email"`
-	Date  string `json:"date"`
-}
-
-type wikiPage struct {
-	Title         string      `json:"title"`
-	HTMLURL       string      `json:"html_url"`
-	SubURL        string      `json:"sub_url"`
-	ContentBase64 string      `json:"content_base64"`
-	LastCommit    *wikiCommit `json:"last_commit"`
-	// Decoded content for JSON output
-	Content string `json:"content,omitempty"`
-}
-
-type wikiCreateRequest struct {
-	Title         string `json:"title"`
-	ContentBase64 string `json:"content_base64"`
-}
-
-var wikiCmd = &cobra.Command{
-	Use:   "wiki",
-	Short: "Manage repository wiki pages",
-	Long:  "View and manage wiki pages for a repository.",
-}
-
-var wikiListCmd = &cobra.Command{
-	Use:   "list",
-	Short: "List wiki pages",
-	Long:  "List all wiki pages for a repository.",
-	Example: `  # List wiki pages for the current repo
-  fj wiki list
-
-  # List wiki pages for a specific repo
-  fj wiki list -R owner/repo
-
-  # Output as JSON
-  fj wiki list --json`,
-	RunE: runWikiList,
-}
-
-var wikiViewCmd = &cobra.Command{
-	Use:   "view <title>",
-	Short: "View a wiki page",
-	Long:  "Display the content of a wiki page.",
-	Example: `  # View a wiki page
-  fj wiki view Home
-
-  # Open in browser
-  fj wiki view Home --web
-
-  # View a wiki page as JSON (includes content)
-  fj wiki view Home --json
-
-  # View a wiki page from a specific repo
-  fj wiki view "Getting-Started" -R owner/repo`,
-	Args: cobra.ExactArgs(1),
-	RunE: runWikiView,
-}
-
-var wikiCreateCmd = &cobra.Command{
-	Use:   "create <title>",
-	Short: "Create a wiki page",
-	Long:  "Create a new wiki page in the repository.",
-	Example: `  # Create a wiki page with inline content
-  fj wiki create "Getting Started" -b "# Welcome\nThis is the getting started guide."
-
-  # Create a wiki page from a file
-  fj wiki create "Setup Guide" --body-file setup.md
-
-  # Create a wiki page from stdin
-  echo "# FAQ" | fj wiki create FAQ --body-file -
-
-  # Output as JSON
-  fj wiki create "New Page" -b "Content here" --json`,
-	Args: cobra.ExactArgs(1),
-	RunE: runWikiCreate,
-}
-
-var wikiEditCmd = &cobra.Command{
-	Use:   "edit <title>",
-	Short: "Edit a wiki page",
-	Long:  "Edit an existing wiki page in the repository.",
-	Example: `  # Edit a wiki page with new content
-  fj wiki edit Home -b "# Updated Home\nNew content here."
-
-  # Edit a wiki page from a file
-  fj wiki edit "Setup Guide" --body-file updated-setup.md
-
-  # Edit a wiki page from stdin
-  cat new-content.md | fj wiki edit Home --body-file -
-
-  # Output as JSON
-  fj wiki edit Home -b "Updated content" --json`,
-	Args: cobra.ExactArgs(1),
-	RunE: runWikiEdit,
-}
-
-var wikiDeleteCmd = &cobra.Command{
-	Use:   "delete <title>",
-	Short: "Delete a wiki page",
-	Long:  "Delete a wiki page from the repository.",
-	Example: `  # Delete a wiki page
-  fj wiki delete "Old Page"
-
-  # Delete without confirmation
-  fj wiki delete "Old Page" -y
-
-  # Delete a wiki page from a specific repo
-  fj wiki delete "Outdated Guide" -R owner/repo`,
-	Args: cobra.ExactArgs(1),
-	RunE: runWikiDelete,
-}
-
-func init() {
-	rootCmd.AddCommand(wikiCmd)
-	wikiCmd.AddCommand(wikiListCmd)
-	wikiCmd.AddCommand(wikiViewCmd)
-	wikiCmd.AddCommand(wikiCreateCmd)
-	wikiCmd.AddCommand(wikiEditCmd)
-	wikiCmd.AddCommand(wikiDeleteCmd)
-
-	wikiListCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	addJSONFlags(wikiListCmd, "Output as JSON")
-
-	wikiViewCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	addJSONFlags(wikiViewCmd, "Output as JSON")
-	wikiViewCmd.Flags().BoolP("web", "w", false, "Open in web browser")
-
-	wikiCreateCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	wikiCreateCmd.Flags().StringP("body", "b", "", "Wiki page content")
-	wikiCreateCmd.Flags().String("body-file", "", "Read content from file (use \"-\" for stdin)")
-	addJSONFlags(wikiCreateCmd, "Output created page as JSON")
-
-	wikiEditCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	wikiEditCmd.Flags().StringP("body", "b", "", "Wiki page content")
-	wikiEditCmd.Flags().String("body-file", "", "Read content from file (use \"-\" for stdin)")
-	addJSONFlags(wikiEditCmd, "Output updated page as JSON")
-
-	wikiDeleteCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
-	wikiDeleteCmd.Flags().BoolP("yes", "y", false, "Skip confirmation prompt")
-}
-
-func newWikiClient(cmd *cobra.Command) (*api.Client, string, string, error) {
-	repo, _ := cmd.Flags().GetString("repo")
-	owner, name, err := parseRepo(repo)
-	if err != nil {
-		return nil, "", "", err
-	}
-
-	cfg, err := config.Load()
-	if err != nil {
-		return nil, "", "", err
-	}
-
-	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
-	if err != nil {
-		return nil, "", "", err
-	}
-
-	return client, owner, name, nil
-}
-
-func runWikiList(cmd *cobra.Command, args []string) error {
-	client, owner, name, err := newWikiClient(cmd)
-	if err != nil {
-		return err
-	}
-
-	path := fmt.Sprintf("/api/v1/repos/%s/%s/wiki/pages", url.PathEscape(owner), url.PathEscape(name))
-
-	ios.StartSpinner("Fetching wiki pages...")
-	var pages []wikiPageMeta
-	if err := client.GetJSON(path, &pages); err != nil {
-		ios.StopSpinner()
-		return fmt.Errorf("failed to list wiki pages: %w", err)
-	}
-	ios.StopSpinner()
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, pages)
-	}
-
-	if len(pages) == 0 {
-		fmt.Fprintln(ios.Out, "No wiki pages found")
-		return nil
-	}
-
-	isTTY := ios.IsStdoutTTY()
-	tp := ios.NewTablePrinter()
-	tp.AddHeader("TITLE", "LAST UPDATED")
-	for _, p := range pages {
-		updated := ""
-		if p.LastCommit != nil && p.LastCommit.Committer != nil && p.LastCommit.Committer.Date != "" {
-			if t, err := time.Parse(time.RFC3339, p.LastCommit.Committer.Date); err == nil {
-				updated = text.FormatDate(t, isTTY)
-			} else {
-				updated = p.LastCommit.Committer.Date
-			}
-		}
-		tp.AddRow(p.Title, updated)
-	}
-	return tp.Render()
-}
-
-func runWikiView(cmd *cobra.Command, args []string) error {
-	title := args[0]
-
-	client, owner, name, err := newWikiClient(cmd)
-	if err != nil {
-		return err
-	}
-
-	path := fmt.Sprintf("/api/v1/repos/%s/%s/wiki/page/%s",
-		url.PathEscape(owner), url.PathEscape(name), url.PathEscape(title))
-
-	ios.StartSpinner("Fetching wiki page...")
-	var page wikiPage
-	if err := client.GetJSON(path, &page); err != nil {
-		ios.StopSpinner()
-		return fmt.Errorf("failed to get wiki page: %w", err)
-	}
-	ios.StopSpinner()
-
-	content, err := base64.StdEncoding.DecodeString(page.ContentBase64)
-	if err != nil {
-		return fmt.Errorf("failed to decode wiki page content: %w", err)
-	}
-
-	if web, _ := cmd.Flags().GetBool("web"); web {
-		if page.HTMLURL != "" {
-			return ios.OpenInBrowser(page.HTMLURL)
-		}
-		return fmt.Errorf("wiki page has no HTML URL")
-	}
-
-	if wantJSON(cmd) {
-		page.Content = string(content)
-		return outputJSON(cmd, page)
-	}
-
-	if err := ios.StartPager(); err != nil {
-		fmt.Fprintf(ios.ErrOut, "warning: failed to start pager: %v\n", err)
-	}
-	defer ios.StopPager()
-
-	fmt.Fprintf(ios.Out, "# %s\n\n", page.Title)
-	fmt.Fprint(ios.Out, string(content))
-	// Ensure trailing newline
-	if len(content) > 0 && content[len(content)-1] != '\n' {
-		fmt.Fprintln(ios.Out)
-	}
-
-	return nil
-}
-
-func runWikiCreate(cmd *cobra.Command, args []string) error {
-	title := args[0]
-
-	client, owner, name, err := newWikiClient(cmd)
-	if err != nil {
-		return err
-	}
-
-	body, err := readBody(cmd)
-	if err != nil {
-		return err
-	}
-	if body == "" {
-		return fmt.Errorf("content is required (use --body or --body-file)")
-	}
-
-	path := fmt.Sprintf("/api/v1/repos/%s/%s/wiki/new",
-		url.PathEscape(owner), url.PathEscape(name))
-
-	reqBody := wikiCreateRequest{
-		Title:         title,
-		ContentBase64: base64.StdEncoding.EncodeToString([]byte(body)),
-	}
-
-	ios.StartSpinner("Creating wiki page...")
-	var page wikiPage
-	if _, err := client.DoJSON(http.MethodPost, path, reqBody, &page); err != nil {
-		ios.StopSpinner()
-		return fmt.Errorf("failed to create wiki page: %w", err)
-	}
-	ios.StopSpinner()
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, page)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Wiki page created: %s\n", cs.SuccessIcon(), title)
-	return nil
-}
-
-func runWikiEdit(cmd *cobra.Command, args []string) error {
-	title := args[0]
-
-	client, owner, name, err := newWikiClient(cmd)
-	if err != nil {
-		return err
-	}
-
-	body, err := readBody(cmd)
-	if err != nil {
-		return err
-	}
-	if body == "" {
-		return fmt.Errorf("content is required (use --body or --body-file)")
-	}
-
-	path := fmt.Sprintf("/api/v1/repos/%s/%s/wiki/page/%s",
-		url.PathEscape(owner), url.PathEscape(name), url.PathEscape(title))
-
-	reqBody := wikiCreateRequest{
-		Title:         title,
-		ContentBase64: base64.StdEncoding.EncodeToString([]byte(body)),
-	}
-
-	ios.StartSpinner("Updating wiki page...")
-	var page wikiPage
-	if _, err := client.DoJSON(http.MethodPatch, path, reqBody, &page); err != nil {
-		ios.StopSpinner()
-		return fmt.Errorf("failed to update wiki page: %w", err)
-	}
-	ios.StopSpinner()
-
-	if wantJSON(cmd) {
-		return outputJSON(cmd, page)
-	}
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Wiki page updated: %s\n", cs.SuccessIcon(), title)
-	return nil
-}
-
-func runWikiDelete(cmd *cobra.Command, args []string) error {
-	title := args[0]
-	yes, _ := cmd.Flags().GetBool("yes")
-
-	client, owner, name, err := newWikiClient(cmd)
-	if err != nil {
-		return err
-	}
-
-	if !yes {
-		confirmed, err := ios.ConfirmAction(fmt.Sprintf("Delete wiki page %q?", title))
-		if err != nil {
-			return err
-		}
-		if !confirmed {
-			fmt.Fprintln(ios.ErrOut, "Aborted")
-			return nil
-		}
-	}
-
-	path := fmt.Sprintf("/api/v1/repos/%s/%s/wiki/page/%s",
-		url.PathEscape(owner), url.PathEscape(name), url.PathEscape(title))
-
-	ios.StartSpinner("Deleting wiki page...")
-	if _, err := client.DoJSON(http.MethodDelete, path, nil, nil); err != nil {
-		ios.StopSpinner()
-		return fmt.Errorf("failed to delete wiki page: %w", err)
-	}
-	ios.StopSpinner()
-
-	cs := ios.ColorScheme()
-	fmt.Fprintf(ios.Out, "%s Wiki page deleted: %s\n", cs.SuccessIcon(), title)
-	return nil
-}
diff --git a/go.mod b/go.mod
index 1c216be..66a6f73 100644
--- a/go.mod
+++ b/go.mod
@@ -1,6 +1,6 @@
-module forgejo.zerova.net/public/fj
+module codeberg.org/romaintb/fgj
 
-go 1.24.0
+go 1.23.0
 
 require (
 	code.gitea.io/sdk/gitea v0.22.1
@@ -12,19 +12,15 @@ require (
 
 require (
 	github.com/42wim/httpsig v1.2.3 // indirect
-	github.com/cpuguy83/go-md2man/v2 v2.0.4 // indirect
 	github.com/davidmz/go-pageant v1.0.2 // indirect
 	github.com/fsnotify/fsnotify v1.7.0 // indirect
 	github.com/go-fed/httpsig v1.1.0 // indirect
 	github.com/hashicorp/go-version v1.7.0 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/itchyny/gojq v0.12.18 // indirect
-	github.com/itchyny/timefmt-go v0.1.7 // indirect
 	github.com/magiconair/properties v1.8.7 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
-	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/sagikazarmark/locafero v0.4.0 // indirect
 	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
 	github.com/sourcegraph/conc v0.3.0 // indirect
@@ -36,7 +32,7 @@ require (
 	go.uber.org/multierr v1.9.0 // indirect
 	golang.org/x/crypto v0.39.0 // indirect
 	golang.org/x/exp v0.0.0-20230905200255-921286631fa9 // indirect
-	golang.org/x/sys v0.38.0 // indirect
+	golang.org/x/sys v0.33.0 // indirect
 	golang.org/x/text v0.26.0 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 )
diff --git a/go.sum b/go.sum
index 7618c0c..a28f421 100644
--- a/go.sum
+++ b/go.sum
@@ -2,7 +2,6 @@ code.gitea.io/sdk/gitea v0.22.1 h1:7K05KjRORyTcTYULQ/AwvlVS6pawLcWyXZcTr7gHFyA=
 code.gitea.io/sdk/gitea v0.22.1/go.mod h1:yyF5+GhljqvA30sRDreoyHILruNiy4ASufugzYg0VHM=
 github.com/42wim/httpsig v1.2.3 h1:xb0YyWhkYj57SPtfSttIobJUPJZB9as1nsfo7KWVcEs=
 github.com/42wim/httpsig v1.2.3/go.mod h1:nZq9OlYKDrUBhptd77IHx4/sZZD+IxTBADvAPI9G/EM=
-github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4=
 github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -24,10 +23,6 @@ github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-github.com/itchyny/gojq v0.12.18 h1:gFGHyt/MLbG9n6dqnvlliiya2TaMMh6FFaR2b1H6Drc=
-github.com/itchyny/gojq v0.12.18/go.mod h1:4hPoZ/3lN9fDL1D+aK7DY1f39XZpY9+1Xpjz8atrEkg=
-github.com/itchyny/timefmt-go v0.1.7 h1:xyftit9Tbw+Dc/huSSPJaEmX1TVL8lw5vxjJLK4GMMA=
-github.com/itchyny/timefmt-go v0.1.7/go.mod h1:5E46Q+zj7vbTgWY8o5YkMeYb4I6GeWLFnetPy5oBrAI=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
@@ -43,7 +38,6 @@ github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRI
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
-github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ=
 github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4=
@@ -92,8 +86,6 @@ golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
 golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
-golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
 golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
diff --git a/internal/api/client.go b/internal/api/client.go
index 0666357..42067c6 100644
--- a/internal/api/client.go
+++ b/internal/api/client.go
@@ -1,27 +1,15 @@
 package api
 
 import (
-	"bytes"
 	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
-	"time"
 
 	"code.gitea.io/sdk/gitea"
-	"forgejo.zerova.net/public/fj/internal/config"
+	"codeberg.org/romaintb/fgj/internal/config"
 )
 
-// SharedHTTPClient is the package-wide HTTP client. Exported so other
-// packages (notably cmd/api.go) can reuse the same timeout and connection
-// pooling instead of constructing zero-value clients with no timeout.
-var SharedHTTPClient = &http.Client{
-	Timeout: 30 * time.Second,
-}
-
-// Internal alias kept so existing call sites compile unchanged.
-var sharedHTTPClient = SharedHTTPClient
-
 type Client struct {
 	*gitea.Client
 	hostname string
@@ -45,8 +33,8 @@ func NewClient(hostname, token string) (*Client, error) {
 	}, nil
 }
 
-func NewClientFromConfig(cfg *config.Config, hostname string, detectedHost string, cwd string) (*Client, error) {
-	host, err := cfg.GetHost(hostname, detectedHost, cwd)
+func NewClientFromConfig(cfg *config.Config, hostname string) (*Client, error) {
+	host, err := cfg.GetHost(hostname)
 	if err != nil {
 		return nil, err
 	}
@@ -74,7 +62,8 @@ func (c *Client) GetJSON(path string, result any) error {
 	}
 	req.Header.Set("Accept", "application/json")
 
-	resp, err := sharedHTTPClient.Do(req)
+	httpClient := &http.Client{}
+	resp, err := httpClient.Do(req)
 	if err != nil {
 		return fmt.Errorf("failed to perform request: %w", err)
 	}
@@ -84,16 +73,9 @@ func (c *Client) GetJSON(path string, result any) error {
 		}
 	}()
 
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		body, readErr := io.ReadAll(resp.Body)
-		if readErr != nil {
-			return fmt.Errorf("failed to read error response body: %w", readErr)
-		}
-		return &APIError{
-			StatusCode: resp.StatusCode,
-			Body:       string(body),
-			Message:    fmt.Sprintf("API request failed with status %d: %s", resp.StatusCode, string(body)),
-		}
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))
 	}
 
 	if err := json.NewDecoder(resp.Body).Decode(result); err != nil {
@@ -103,106 +85,6 @@ func (c *Client) GetJSON(path string, result any) error {
 	return nil
 }
 
-// PostJSON performs a POST request to the specified path with JSON body
-func (c *Client) PostJSON(path string, body any, result any) error {
-	_, err := c.DoJSON(http.MethodPost, path, body, result)
-	return err
-}
-
-// DoJSON performs an HTTP request with a JSON body and decodes the JSON response.
-// Returns the HTTP status code and any error encountered.
-func (c *Client) DoJSON(method string, path string, body any, result any) (int, error) {
-	baseURL := "https://" + c.hostname
-	url := baseURL + path
-
-	var bodyReader io.Reader
-	if body != nil {
-		bodyBytes, err := json.Marshal(body)
-		if err != nil {
-			return 0, fmt.Errorf("failed to marshal request body: %w", err)
-		}
-		bodyReader = bytes.NewReader(bodyBytes)
-	}
-
-	req, err := http.NewRequest(method, url, bodyReader)
-	if err != nil {
-		return 0, fmt.Errorf("failed to create request: %w", err)
-	}
-
-	// Set authentication header
-	if c.token != "" {
-		req.Header.Set("Authorization", "token "+c.token)
-	}
-	req.Header.Set("Accept", "application/json")
-	if body != nil {
-		req.Header.Set("Content-Type", "application/json")
-	}
-
-	resp, err := sharedHTTPClient.Do(req)
-	if err != nil {
-		return 0, fmt.Errorf("failed to perform request: %w", err)
-	}
-	defer func() {
-		if closeErr := resp.Body.Close(); closeErr != nil && err == nil {
-			err = fmt.Errorf("failed to close response body: %w", closeErr)
-		}
-	}()
-
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		bodyBytes, readErr := io.ReadAll(resp.Body)
-		if readErr != nil {
-			return resp.StatusCode, fmt.Errorf("failed to read error response body: %w", readErr)
-		}
-		return resp.StatusCode, &APIError{
-			StatusCode: resp.StatusCode,
-			Body:       string(bodyBytes),
-			Message:    fmt.Sprintf("API request failed with status %d: %s", resp.StatusCode, string(bodyBytes)),
-		}
-	}
-
-	if result != nil && resp.StatusCode != http.StatusNoContent {
-		if err := json.NewDecoder(resp.Body).Decode(result); err != nil {
-			return resp.StatusCode, fmt.Errorf("failed to decode response: %w", err)
-		}
-	}
-
-	return resp.StatusCode, nil
-}
-
-// Token returns the client's authentication token.
-func (c *Client) Token() string {
-	return c.token
-}
-
-// DownloadFile performs an authenticated GET request and writes the response body to the given writer.
-func (c *Client) DownloadFile(url string, w io.Writer) error {
-	req, err := http.NewRequest(http.MethodGet, url, nil)
-	if err != nil {
-		return fmt.Errorf("failed to create request: %w", err)
-	}
-
-	if c.token != "" {
-		req.Header.Set("Authorization", "token "+c.token)
-	}
-
-	resp, err := sharedHTTPClient.Do(req)
-	if err != nil {
-		return fmt.Errorf("failed to perform request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		body, _ := io.ReadAll(resp.Body)
-		return fmt.Errorf("download failed with status %d: %s", resp.StatusCode, string(body))
-	}
-
-	if _, err := io.Copy(w, resp.Body); err != nil {
-		return fmt.Errorf("failed to write file: %w", err)
-	}
-
-	return nil
-}
-
 // GetRawLog performs a GET request and returns the raw response body as string
 func (c *Client) GetRawLog(url string) (string, error) {
 	req, err := http.NewRequest(http.MethodGet, url, nil)
@@ -215,7 +97,8 @@ func (c *Client) GetRawLog(url string) (string, error) {
 		req.Header.Set("Authorization", "token "+c.token)
 	}
 
-	resp, err := sharedHTTPClient.Do(req)
+	httpClient := &http.Client{}
+	resp, err := httpClient.Do(req)
 	if err != nil {
 		return "", fmt.Errorf("failed to perform request: %w", err)
 	}
@@ -226,15 +109,8 @@ func (c *Client) GetRawLog(url string) (string, error) {
 	}()
 
 	if resp.StatusCode != http.StatusOK {
-		body, readErr := io.ReadAll(resp.Body)
-		if readErr != nil {
-			return "", fmt.Errorf("failed to read error response body: %w", readErr)
-		}
-		return "", &APIError{
-			StatusCode: resp.StatusCode,
-			Body:       string(body),
-			Message:    fmt.Sprintf("API request failed with status %d: %s", resp.StatusCode, string(body)),
-		}
+		body, _ := io.ReadAll(resp.Body)
+		return "", fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))
 	}
 
 	bodyBytes, err := io.ReadAll(resp.Body)
diff --git a/internal/api/client_test.go b/internal/api/client_test.go
index 2dba74c..0bbc3ca 100644
--- a/internal/api/client_test.go
+++ b/internal/api/client_test.go
@@ -3,7 +3,7 @@ package api
 import (
 	"testing"
 
-	"forgejo.zerova.net/public/fj/internal/config"
+	"codeberg.org/romaintb/fgj/internal/config"
 )
 
 func TestClient_Hostname(t *testing.T) {
@@ -21,7 +21,7 @@ func TestNewClientFromConfig_MissingHost(t *testing.T) {
 		Hosts: map[string]config.HostConfig{},
 	}
 
-	_, err := NewClientFromConfig(cfg, "nonexistent.org", "", "")
+	_, err := NewClientFromConfig(cfg, "nonexistent.org")
 	if err == nil {
 		t.Error("Expected error for nonexistent host")
 	}
diff --git a/internal/api/errors.go b/internal/api/errors.go
deleted file mode 100644
index 90b5e3d..0000000
--- a/internal/api/errors.go
+++ /dev/null
@@ -1,17 +0,0 @@
-package api
-
-import "fmt"
-
-// APIError represents a non-2xx HTTP response from the Forgejo API.
-type APIError struct {
-	StatusCode int
-	Body       string
-	Message    string
-}
-
-func (e *APIError) Error() string {
-	if e.Body != "" {
-		return fmt.Sprintf("API request failed with status %d: %s", e.StatusCode, e.Body)
-	}
-	return fmt.Sprintf("API request failed with status %d: %s", e.StatusCode, e.Message)
-}
diff --git a/internal/config/config.go b/internal/config/config.go
index 79c5c0b..41c7409 100644
--- a/internal/config/config.go
+++ b/internal/config/config.go
@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"strings"
 
 	"github.com/spf13/viper"
 	"gopkg.in/yaml.v3"
@@ -14,41 +13,22 @@ type Config struct {
 	Hosts map[string]HostConfig `yaml:"hosts"`
 }
 
-// explicitConfigPath, when non-empty, overrides the default config file
-// location for both Load() and Save(). It's set by cmd/root.initConfig when
-// the user passes --config <path>. Stored at package scope so existing
-// call sites of config.Load()/c.Save() continue to work without each one
-// having to know about the flag.
-var explicitConfigPath string
-
-// SetExplicitConfigPath wires a user-supplied --config path through to
-// Load/Save. Pass "" to clear.
-func SetExplicitConfigPath(p string) { explicitConfigPath = p }
-
 type HostConfig struct {
-	Hostname    string   `yaml:"hostname"`
-	Token       string   `yaml:"token"`
-	User        string   `yaml:"user,omitempty"`
-	GitProtocol string   `yaml:"git_protocol,omitempty"`
-	MatchDirs   []string `yaml:"match_dirs,omitempty"`
-	Order       int      `yaml:"-"` // config file order, set at load time
+	Hostname string `yaml:"hostname"`
+	Token    string `yaml:"token"`
+	User     string `yaml:"user,omitempty"`
+	GitProtocol string `yaml:"git_protocol,omitempty"`
 }
 
 func GetConfigDir() (string, error) {
-	if xdgConfigHome := os.Getenv("XDG_CONFIG_HOME"); xdgConfigHome != "" {
-		return filepath.Join(xdgConfigHome, "fj"), nil
-	}
 	home, err := os.UserHomeDir()
 	if err != nil {
 		return "", err
 	}
-	return filepath.Join(home, ".config", "fj"), nil
+	return filepath.Join(home, ".config", "fgj"), nil
 }
 
 func GetConfigPath() (string, error) {
-	if explicitConfigPath != "" {
-		return explicitConfigPath, nil
-	}
 	dir, err := GetConfigDir()
 	if err != nil {
 		return "", err
@@ -82,43 +62,9 @@ func LoadFromPath(path string) (*Config, error) {
 		cfg.Hosts = make(map[string]HostConfig)
 	}
 
-	// Parse again with yaml.Node to capture config file order for hosts
-	assignHostOrder(&cfg, data)
-
 	return &cfg, nil
 }
 
-// assignHostOrder walks the YAML document tree to find the "hosts" mapping
-// and stamps each HostConfig.Order with its position in the file.
-func assignHostOrder(cfg *Config, data []byte) {
-	var doc yaml.Node
-	if err := yaml.Unmarshal(data, &doc); err != nil || len(doc.Content) == 0 {
-		return
-	}
-	root := doc.Content[0] // mapping node
-	if root.Kind != yaml.MappingNode {
-		return
-	}
-	for i := 0; i+1 < len(root.Content); i += 2 {
-		if root.Content[i].Value == "hosts" {
-			hostsNode := root.Content[i+1]
-			if hostsNode.Kind != yaml.MappingNode {
-				return
-			}
-			order := 0
-			for j := 0; j+1 < len(hostsNode.Content); j += 2 {
-				key := hostsNode.Content[j].Value
-				if h, ok := cfg.Hosts[key]; ok {
-					h.Order = order
-					cfg.Hosts[key] = h
-					order++
-				}
-			}
-			return
-		}
-	}
-}
-
 func (c *Config) Save() error {
 	path, err := GetConfigPath()
 	if err != nil {
@@ -141,29 +87,13 @@ func (c *Config) SaveToPath(path string) error {
 	return os.WriteFile(path, data, 0600)
 }
 
-// GetHost resolves the hostname to use for API client creation.
-// Priority order:
-// 1. Explicitly provided hostname parameter
-// 2. CLI flag (--hostname)
-// 3. Environment variable (FJ_HOST, with FGJ_HOST fallback)
-// 4. Auto-detected hostname from git remote
-// 5. match_dirs lookup (longest prefix match)
-// 6. Default to codeberg.org
-func (c *Config) GetHost(hostname string, detectedHost string, cwd string) (HostConfig, error) {
+func (c *Config) GetHost(hostname string) (HostConfig, error) {
 	if hostname == "" {
 		hostname = viper.GetString("hostname")
 	}
 
 	if hostname == "" {
-		hostname = EnvWithFallback("FJ_HOST", "FGJ_HOST")
-	}
-
-	if hostname == "" {
-		hostname = detectedHost
-	}
-
-	if hostname == "" {
-		hostname = c.ResolveHostByPath(cwd)
+		hostname = os.Getenv("FGJ_HOST")
 	}
 
 	if hostname == "" {
@@ -178,90 +108,6 @@ func (c *Config) GetHost(hostname string, detectedHost string, cwd string) (Host
 	return host, nil
 }
 
-// ResolveHostByPath finds the host whose match_dirs entry is the longest
-// prefix of cwd. Returns "" if no match is found.
-// Both cwd and match_dirs entries are resolved through filepath.EvalSymlinks
-// to handle symlinks (e.g. macOS /tmp → /private/tmp).
-// On ties (same prefix length from multiple hosts), the host appearing first
-// in the config file wins and a warning is printed to stderr.
-func (c *Config) ResolveHostByPath(cwd string) string {
-	if cwd == "" {
-		return ""
-	}
-
-	// Resolve symlinks in cwd so /tmp becomes /private/tmp on macOS, etc.
-	if resolved, err := filepath.EvalSymlinks(cwd); err == nil {
-		cwd = resolved
-	}
-
-	bestHost := ""
-	bestLen := 0
-	bestOrder := 0
-	tied := false
-
-	for hostname, host := range c.Hosts {
-		for _, dir := range host.MatchDirs {
-			if dir == "" {
-				continue
-			}
-			// Expand ~ to home directory
-			dir = expandHome(dir)
-			// Resolve symlinks in the configured dir as well
-			if resolved, err := filepath.EvalSymlinks(dir); err == nil {
-				dir = resolved
-			}
-			// Normalize: ensure trailing slash for prefix matching
-			prefix := dir
-			if !strings.HasSuffix(prefix, "/") {
-				prefix += "/"
-			}
-			// Match if cwd equals dir exactly or is under it
-			if cwd == dir || strings.HasPrefix(cwd, prefix) {
-				if len(dir) > bestLen {
-					bestLen = len(dir)
-					bestHost = hostname
-					bestOrder = host.Order
-					tied = false
-				} else if len(dir) == bestLen && hostname != bestHost {
-					// Tie — pick the host with the lower Order (earlier in config)
-					if host.Order < bestOrder {
-						bestHost = hostname
-						bestOrder = host.Order
-					}
-					tied = true
-				}
-			}
-		}
-	}
-
-	if tied {
-		fmt.Fprintf(os.Stderr, "warning: multiple hosts match directory %q with the same specificity; using %s (first in config)\n", cwd, bestHost)
-	}
-
-	return bestHost
-}
-
-// expandHome replaces a leading ~ with the user's home directory.
-// EnvWithFallback returns the value of the primary env var, falling back to
-// the legacy name if the primary is unset. This eases the FGJ_ → FJ_ rename.
-func EnvWithFallback(primary, legacy string) string {
-	if v := os.Getenv(primary); v != "" {
-		return v
-	}
-	return os.Getenv(legacy)
-}
-
-func expandHome(path string) string {
-	if path == "~" || strings.HasPrefix(path, "~/") {
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return path
-		}
-		return filepath.Join(home, path[1:])
-	}
-	return path
-}
-
 func (c *Config) SetHost(hostname string, host HostConfig) {
 	if c.Hosts == nil {
 		c.Hosts = make(map[string]HostConfig)
diff --git a/internal/config/config_test.go b/internal/config/config_test.go
index 4300e45..0999170 100644
--- a/internal/config/config_test.go
+++ b/internal/config/config_test.go
@@ -49,7 +49,7 @@ func TestConfig_GetHost(t *testing.T) {
 		},
 	}
 
-	host, err := cfg.GetHost("codeberg.org", "", "")
+	host, err := cfg.GetHost("codeberg.org")
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
@@ -58,7 +58,7 @@ func TestConfig_GetHost(t *testing.T) {
 		t.Errorf("Expected hostname 'codeberg.org', got '%s'", host.Hostname)
 	}
 
-	_, err = cfg.GetHost("nonexistent.org", "", "")
+	_, err = cfg.GetHost("nonexistent.org")
 	if err == nil {
 		t.Error("Expected error for nonexistent host")
 	}
@@ -75,20 +75,6 @@ func TestGetConfigDir(t *testing.T) {
 	}
 }
 
-func TestGetConfigDir_XDG(t *testing.T) {
-	t.Setenv("XDG_CONFIG_HOME", "/custom/config")
-
-	dir, err := GetConfigDir()
-	if err != nil {
-		t.Fatalf("Unexpected error: %v", err)
-	}
-
-	expected := "/custom/config/fj"
-	if dir != expected {
-		t.Errorf("Expected %q, got %q", expected, dir)
-	}
-}
-
 func TestGetConfigPath(t *testing.T) {
 	path, err := GetConfigPath()
 	if err != nil {
@@ -275,7 +261,7 @@ func TestConfig_GetHost_EmptyString(t *testing.T) {
 	}
 
 	// Empty hostname should default to codeberg.org
-	host, err := cfg.GetHost("", "", "")
+	host, err := cfg.GetHost("")
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
@@ -296,7 +282,7 @@ func TestConfig_GetHost_WhitespaceString(t *testing.T) {
 	}
 
 	// Whitespace-only hostname should default to codeberg.org
-	host, err := cfg.GetHost("   ", "", "")
+	host, err := cfg.GetHost("   ")
 	if err == nil {
 		t.Logf("Got host: %+v (this may be expected behavior)", host)
 	} else {
@@ -315,7 +301,7 @@ func TestConfig_SetHost_EmptyToken(t *testing.T) {
 
 	cfg.SetHost("codeberg.org", hostConfig)
 
-	host, err := cfg.GetHost("codeberg.org", "", "")
+	host, err := cfg.GetHost("codeberg.org")
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
@@ -345,7 +331,7 @@ func TestConfig_SetHost_OverwriteExisting(t *testing.T) {
 
 	cfg.SetHost("codeberg.org", newConfig)
 
-	host, err := cfg.GetHost("codeberg.org", "", "")
+	host, err := cfg.GetHost("codeberg.org")
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
@@ -388,7 +374,7 @@ func TestConfig_MultipleHosts(t *testing.T) {
 
 	// Verify each host can be retrieved correctly
 	for _, h := range hosts {
-		host, err := cfg.GetHost(h.hostname, "", "")
+		host, err := cfg.GetHost(h.hostname)
 		if err != nil {
 			t.Errorf("Failed to get host %s: %v", h.hostname, err)
 			continue
@@ -422,233 +408,13 @@ func TestConfig_GitProtocol(t *testing.T) {
 	})
 
 	// Verify protocols are stored correctly
-	sshHost, _ := cfg.GetHost("test-ssh.org", "", "")
+	sshHost, _ := cfg.GetHost("test-ssh.org")
 	if sshHost.GitProtocol != "ssh" {
 		t.Errorf("Expected git_protocol 'ssh', got '%s'", sshHost.GitProtocol)
 	}
 
-	httpsHost, _ := cfg.GetHost("test-https.org", "", "")
+	httpsHost, _ := cfg.GetHost("test-https.org")
 	if httpsHost.GitProtocol != "https" {
 		t.Errorf("Expected git_protocol 'https', got '%s'", httpsHost.GitProtocol)
 	}
 }
-
-func TestResolveHostByPath(t *testing.T) {
-	cfg := &Config{
-		Hosts: map[string]HostConfig{
-			"forgejo.zerova.net": {
-				Hostname:  "forgejo.zerova.net",
-				Token:     "token1",
-				MatchDirs: []string{"/Users/sid/repos/fj", "/Users/sid/repos/zerova"},
-			},
-			"codeberg.org": {
-				Hostname:  "codeberg.org",
-				Token:     "token2",
-				MatchDirs: []string{"/"},
-			},
-			"gitea.example.com": {
-				Hostname: "gitea.example.com",
-				Token:    "token3",
-				// no match_dirs — should never be selected by path
-			},
-		},
-	}
-
-	tests := []struct {
-		name string
-		cwd  string
-		want string
-	}{
-		{"exact dir match", "/Users/sid/repos/fj", "forgejo.zerova.net"},
-		{"nested dir match", "/Users/sid/repos/fj/cmd/root.go", "forgejo.zerova.net"},
-		{"second match dir", "/Users/sid/repos/zerova/pkg", "forgejo.zerova.net"},
-		{"longest prefix wins over /", "/Users/sid/repos/fj/internal", "forgejo.zerova.net"},
-		{"/ as global catch-all", "/tmp", "codeberg.org"},
-		{"/ matches root itself", "/", "codeberg.org"},
-		{"no match_dirs host not selected", "/some/random/path", "codeberg.org"},
-		{"empty cwd returns empty", "", ""},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := cfg.ResolveHostByPath(tt.cwd)
-			if got != tt.want {
-				t.Errorf("ResolveHostByPath(%q) = %q, want %q", tt.cwd, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestResolveHostByPath_LongestPrefixAcrossHosts(t *testing.T) {
-	cfg := &Config{
-		Hosts: map[string]HostConfig{
-			"broad.org": {
-				Hostname:  "broad.org",
-				Token:     "t1",
-				MatchDirs: []string{"/Users/sid"},
-			},
-			"specific.org": {
-				Hostname:  "specific.org",
-				Token:     "t2",
-				MatchDirs: []string{"/Users/sid/repos/myproject"},
-			},
-		},
-	}
-
-	got := cfg.ResolveHostByPath("/Users/sid/repos/myproject/main.go")
-	if got != "specific.org" {
-		t.Errorf("expected specific.org, got %q", got)
-	}
-
-	got = cfg.ResolveHostByPath("/Users/sid/other")
-	if got != "broad.org" {
-		t.Errorf("expected broad.org, got %q", got)
-	}
-}
-
-func TestGetHost_MatchDirsIntegration(t *testing.T) {
-	cfg := &Config{
-		Hosts: map[string]HostConfig{
-			"forgejo.zerova.net": {
-				Hostname:  "forgejo.zerova.net",
-				Token:     "token1",
-				MatchDirs: []string{"/Users/sid/repos/fj"},
-			},
-			"codeberg.org": {
-				Hostname: "codeberg.org",
-				Token:    "token2",
-			},
-		},
-	}
-
-	// cwd match should resolve to forgejo.zerova.net
-	host, err := cfg.GetHost("", "", "/Users/sid/repos/fj/cmd")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if host.Hostname != "forgejo.zerova.net" {
-		t.Errorf("expected forgejo.zerova.net, got %s", host.Hostname)
-	}
-
-	// no cwd match falls through to codeberg.org default
-	host, err = cfg.GetHost("", "", "/tmp")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if host.Hostname != "codeberg.org" {
-		t.Errorf("expected codeberg.org, got %s", host.Hostname)
-	}
-}
-
-func TestResolveHostByPath_TildeExpansion(t *testing.T) {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		t.Skip("cannot determine home directory")
-	}
-
-	cfg := &Config{
-		Hosts: map[string]HostConfig{
-			"tilde.org": {
-				Hostname:  "tilde.org",
-				Token:     "t1",
-				MatchDirs: []string{"~/repos"},
-			},
-		},
-	}
-
-	got := cfg.ResolveHostByPath(filepath.Join(home, "repos", "myproject"))
-	if got != "tilde.org" {
-		t.Errorf("expected tilde.org, got %q", got)
-	}
-
-	got = cfg.ResolveHostByPath(filepath.Join(home, "other"))
-	if got != "" {
-		t.Errorf("expected empty, got %q", got)
-	}
-}
-
-func TestResolveHostByPath_TieBreakByConfigOrder(t *testing.T) {
-	cfg := &Config{
-		Hosts: map[string]HostConfig{
-			"second.org": {
-				Hostname:  "second.org",
-				Token:     "t2",
-				MatchDirs: []string{"/shared/path"},
-				Order:     1,
-			},
-			"first.org": {
-				Hostname:  "first.org",
-				Token:     "t1",
-				MatchDirs: []string{"/shared/path"},
-				Order:     0,
-			},
-		},
-	}
-
-	got := cfg.ResolveHostByPath("/shared/path/subdir")
-	if got != "first.org" {
-		t.Errorf("expected first.org (earlier in config), got %q", got)
-	}
-}
-
-func TestAssignHostOrder(t *testing.T) {
-	yamlData := []byte(`hosts:
-  alpha.org:
-    hostname: alpha.org
-    token: t1
-  beta.org:
-    hostname: beta.org
-    token: t2
-  gamma.org:
-    hostname: gamma.org
-    token: t3
-`)
-	cfg, err := LoadFromPath(writeTempConfig(t, yamlData))
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if cfg.Hosts["alpha.org"].Order != 0 {
-		t.Errorf("alpha.org order = %d, want 0", cfg.Hosts["alpha.org"].Order)
-	}
-	if cfg.Hosts["beta.org"].Order != 1 {
-		t.Errorf("beta.org order = %d, want 1", cfg.Hosts["beta.org"].Order)
-	}
-	if cfg.Hosts["gamma.org"].Order != 2 {
-		t.Errorf("gamma.org order = %d, want 2", cfg.Hosts["gamma.org"].Order)
-	}
-}
-
-func writeTempConfig(t *testing.T, data []byte) string {
-	t.Helper()
-	path := filepath.Join(t.TempDir(), "config.yaml")
-	if err := os.WriteFile(path, data, 0600); err != nil {
-		t.Fatalf("failed to write temp config: %v", err)
-	}
-	return path
-}
-
-func TestExpandHome(t *testing.T) {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		t.Skip("cannot determine home directory")
-	}
-
-	tests := []struct {
-		input string
-		want  string
-	}{
-		{"~/repos", filepath.Join(home, "repos")},
-		{"~", home},
-		{"/absolute/path", "/absolute/path"},
-		{"relative/path", "relative/path"},
-		{"~other", "~other"}, // only ~/... is expanded, not ~user
-	}
-
-	for _, tt := range tests {
-		got := expandHome(tt.input)
-		if got != tt.want {
-			t.Errorf("expandHome(%q) = %q, want %q", tt.input, got, tt.want)
-		}
-	}
-}
diff --git a/internal/git/git.go b/internal/git/git.go
index 0491953..1f0282b 100644
--- a/internal/git/git.go
+++ b/internal/git/git.go
@@ -25,28 +25,7 @@ func DetectRepo() (owner, name string, err error) {
 	}
 
 	// Extract owner/name from URL
-	owner, name, _, err = parseRemoteURL(remoteURL)
-	return owner, name, err
-}
-
-// DetectHost attempts to detect the Forgejo instance hostname from the current git directory.
-// It reads .git/config and parses the origin remote URL to extract the hostname.
-func DetectHost() (hostname string, err error) {
-	// Find .git/config file
-	gitConfigPath, err := findGitConfig()
-	if err != nil {
-		return "", err
-	}
-
-	// Parse .git/config
-	remoteURL, err := parseGitConfig(gitConfigPath)
-	if err != nil {
-		return "", err
-	}
-
-	// Extract hostname from URL
-	_, _, hostname, err = parseRemoteURL(remoteURL)
-	return hostname, err
+	return parseRemoteURL(remoteURL)
 }
 
 // findGitConfig searches for .git/config starting from the current directory
@@ -114,75 +93,33 @@ func parseGitConfig(configPath string) (string, error) {
 	return "", fmt.Errorf("no origin remote found in git config")
 }
 
-// GetCurrentBranch returns the name of the currently checked-out branch.
-func GetCurrentBranch() (string, error) {
-	gitDir, err := findGitDir()
-	if err != nil {
-		return "", err
-	}
-
-	headPath := filepath.Join(gitDir, "HEAD")
-	data, err := os.ReadFile(headPath)
-	if err != nil {
-		return "", fmt.Errorf("failed to read .git/HEAD: %w", err)
-	}
-
-	headStr := strings.TrimSpace(string(data))
-	if strings.HasPrefix(headStr, "ref: refs/heads/") {
-		return strings.TrimPrefix(headStr, "ref: refs/heads/"), nil
-	}
-
-	return "", fmt.Errorf("HEAD is not on a branch (detached HEAD)")
-}
-
-// findGitDir searches for the .git directory starting from the current directory
-func findGitDir() (string, error) {
-	cwd, err := os.Getwd()
-	if err != nil {
-		return "", fmt.Errorf("failed to get current directory: %w", err)
-	}
-
-	dir := cwd
-	for {
-		gitDir := filepath.Join(dir, ".git")
-		if info, err := os.Stat(gitDir); err == nil && info.IsDir() {
-			return gitDir, nil
-		}
-		parent := filepath.Dir(dir)
-		if parent == dir {
-			return "", fmt.Errorf("not in a git repository")
-		}
-		dir = parent
-	}
-}
-
-// parseRemoteURL extracts owner/name/hostname from various git URL formats:
+// parseRemoteURL extracts owner/name from various git URL formats:
 // - https://codeberg.org/owner/name.git
 // - git@codeberg.org:owner/name.git
 // - ssh://git@codeberg.org/owner/name.git
-func parseRemoteURL(url string) (owner, name, hostname string, err error) {
+func parseRemoteURL(url string) (owner, name string, err error) {
 	url = strings.TrimSpace(url)
 
 	// Remove .git suffix
 	url = strings.TrimSuffix(url, ".git")
 
 	// Pattern for HTTPS URLs: https://host/owner/name
-	httpsRegex := regexp.MustCompile(`https?://([^/]+)/([^/]+)/([^/]+)`)
-	if matches := httpsRegex.FindStringSubmatch(url); len(matches) == 4 {
-		return matches[2], matches[3], matches[1], nil
+	httpsRegex := regexp.MustCompile(`https?://[^/]+/([^/]+)/([^/]+)`)
+	if matches := httpsRegex.FindStringSubmatch(url); len(matches) == 3 {
+		return matches[1], matches[2], nil
 	}
 
 	// Pattern for SSH URLs: git@host:owner/name
-	sshRegex := regexp.MustCompile(`git@([^:]+):([^/]+)/(.+)`)
-	if matches := sshRegex.FindStringSubmatch(url); len(matches) == 4 {
-		return matches[2], matches[3], matches[1], nil
+	sshRegex := regexp.MustCompile(`git@[^:]+:([^/]+)/(.+)`)
+	if matches := sshRegex.FindStringSubmatch(url); len(matches) == 3 {
+		return matches[1], matches[2], nil
 	}
 
 	// Pattern for SSH URLs with protocol: ssh://git@host/owner/name
-	sshProtocolRegex := regexp.MustCompile(`ssh://(?:git@)?([^/]+)/([^/]+)/(.+)`)
-	if matches := sshProtocolRegex.FindStringSubmatch(url); len(matches) == 4 {
-		return matches[2], matches[3], matches[1], nil
+	sshProtocolRegex := regexp.MustCompile(`ssh://git@[^/]+/([^/]+)/(.+)`)
+	if matches := sshProtocolRegex.FindStringSubmatch(url); len(matches) == 3 {
+		return matches[1], matches[2], nil
 	}
 
-	return "", "", "", fmt.Errorf("unable to parse repository from URL: %s", url)
+	return "", "", fmt.Errorf("unable to parse repository from URL: %s", url)
 }
diff --git a/internal/git/git_test.go b/internal/git/git_test.go
index a00f4af..da7b90a 100644
--- a/internal/git/git_test.go
+++ b/internal/git/git_test.go
@@ -1,67 +1,56 @@
 package git
 
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
+import "testing"
 
 func TestParseRemoteURL(t *testing.T) {
 	tests := []struct {
-		name      string
-		url       string
+		name    string
+		url     string
 		wantOwner string
 		wantName  string
-		wantHost  string
-		wantErr   bool
+		wantErr bool
 	}{
 		{
-			name:      "HTTPS URL with .git",
-			url:       "https://codeberg.org/romaintb/fj.git",
+			name:    "HTTPS URL with .git",
+			url:     "https://codeberg.org/romaintb/fgj.git",
 			wantOwner: "romaintb",
-			wantName:  "fj",
-			wantHost:  "codeberg.org",
-			wantErr:   false,
+			wantName:  "fgj",
+			wantErr: false,
 		},
 		{
-			name:      "HTTPS URL without .git",
-			url:       "https://codeberg.org/romaintb/fj",
+			name:    "HTTPS URL without .git",
+			url:     "https://codeberg.org/romaintb/fgj",
 			wantOwner: "romaintb",
-			wantName:  "fj",
-			wantHost:  "codeberg.org",
-			wantErr:   false,
+			wantName:  "fgj",
+			wantErr: false,
 		},
 		{
-			name:      "SSH URL with .git",
-			url:       "git@codeberg.org:romaintb/fj.git",
+			name:    "SSH URL with .git",
+			url:     "git@codeberg.org:romaintb/fgj.git",
 			wantOwner: "romaintb",
-			wantName:  "fj",
-			wantHost:  "codeberg.org",
-			wantErr:   false,
+			wantName:  "fgj",
+			wantErr: false,
 		},
 		{
-			name:      "SSH URL without .git",
-			url:       "git@codeberg.org:romaintb/fj",
+			name:    "SSH URL without .git",
+			url:     "git@codeberg.org:romaintb/fgj",
 			wantOwner: "romaintb",
-			wantName:  "fj",
-			wantHost:  "codeberg.org",
-			wantErr:   false,
+			wantName:  "fgj",
+			wantErr: false,
 		},
 		{
-			name:      "SSH protocol URL",
-			url:       "ssh://git@codeberg.org/romaintb/fj.git",
+			name:    "SSH protocol URL",
+			url:     "ssh://git@codeberg.org/romaintb/fgj.git",
 			wantOwner: "romaintb",
-			wantName:  "fj",
-			wantHost:  "codeberg.org",
-			wantErr:   false,
+			wantName:  "fgj",
+			wantErr: false,
 		},
 		{
-			name:      "GitHub HTTPS URL",
-			url:       "https://github.com/user/repo.git",
+			name:    "GitHub HTTPS URL",
+			url:     "https://github.com/user/repo.git",
 			wantOwner: "user",
 			wantName:  "repo",
-			wantHost:  "github.com",
-			wantErr:   false,
+			wantErr: false,
 		},
 		{
 			name:    "Invalid URL",
@@ -74,60 +63,56 @@ func TestParseRemoteURL(t *testing.T) {
 			wantErr: true,
 		},
 		{
-			name:      "URL with trailing whitespace",
-			url:       "  https://codeberg.org/owner/repo.git  ",
+			name:    "URL with trailing whitespace",
+			url:     "  https://codeberg.org/owner/repo.git  ",
 			wantOwner: "owner",
 			wantName:  "repo",
-			wantHost:  "codeberg.org",
-			wantErr:   false,
+			wantErr: false,
 		},
 		{
-			name:      "URL with port number",
-			url:       "https://git.example.com:443/owner/repo.git",
+			name:    "URL with port number",
+			url:     "https://git.example.com:443/owner/repo.git",
 			wantOwner: "owner",
 			wantName:  "repo",
-			wantHost:  "git.example.com:443",
-			wantErr:   false,
+			wantErr: false,
 		},
 		{
-			name:      "SSH URL with port parses incorrectly",
-			url:       "ssh://git@git.example.com:22/owner/repo.git",
+			name:    "SSH URL with port parses incorrectly",
+			url:     "ssh://git@git.example.com:22/owner/repo.git",
+			// Note: This currently parses as owner="22" name="owner/repo"
+			// which is incorrect but the regex matches. We document this
+			// limitation rather than make the test fail.
 			wantOwner: "22",
 			wantName:  "owner/repo",
-			wantHost:  "git.example.com",
-			wantErr:   false,
+			wantErr: false,
 		},
 		{
-			name:      "HTTP URL (not HTTPS)",
-			url:       "http://codeberg.org/owner/repo",
+			name:    "HTTP URL (not HTTPS)",
+			url:     "http://codeberg.org/owner/repo",
 			wantOwner: "owner",
 			wantName:  "repo",
-			wantHost:  "codeberg.org",
-			wantErr:   false,
+			wantErr: false,
 		},
 		{
-			name:      "Repo name with dashes",
-			url:       "https://codeberg.org/owner/my-cool-repo.git",
+			name:    "Repo name with dashes",
+			url:     "https://codeberg.org/owner/my-cool-repo.git",
 			wantOwner: "owner",
 			wantName:  "my-cool-repo",
-			wantHost:  "codeberg.org",
-			wantErr:   false,
+			wantErr: false,
 		},
 		{
-			name:      "Repo name with dots",
-			url:       "https://codeberg.org/owner/my.repo.name.git",
+			name:    "Repo name with dots",
+			url:     "https://codeberg.org/owner/my.repo.name.git",
 			wantOwner: "owner",
 			wantName:  "my.repo.name",
-			wantHost:  "codeberg.org",
-			wantErr:   false,
+			wantErr: false,
 		},
 		{
-			name:      "Owner with dots",
-			url:       "https://codeberg.org/owner.name/repo.git",
+			name:    "Owner with dots",
+			url:     "https://codeberg.org/owner.name/repo.git",
 			wantOwner: "owner.name",
 			wantName:  "repo",
-			wantHost:  "codeberg.org",
-			wantErr:   false,
+			wantErr: false,
 		},
 		{
 			name:    "Missing owner/repo",
@@ -143,7 +128,7 @@ func TestParseRemoteURL(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			owner, name, host, err := parseRemoteURL(tt.url)
+			owner, name, err := parseRemoteURL(tt.url)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("parseRemoteURL() error = %v, wantErr %v", err, tt.wantErr)
 				return
@@ -155,112 +140,6 @@ func TestParseRemoteURL(t *testing.T) {
 				if name != tt.wantName {
 					t.Errorf("parseRemoteURL() name = %v, want %v", name, tt.wantName)
 				}
-				if host != tt.wantHost {
-					t.Errorf("parseRemoteURL() host = %v, want %v", host, tt.wantHost)
-				}
-			}
-		})
-	}
-}
-
-func TestDetectHost(t *testing.T) {
-	tests := []struct {
-		name      string
-		gitConfig string
-		wantHost  string
-		wantErr   bool
-	}{
-		{
-			name: "HTTPS URL",
-			gitConfig: `[core]
-	repositoryformatversion = 0
-[remote "origin"]
-	url = https://codeberg.org/owner/repo.git
-	fetch = +refs/heads/*:refs/remotes/origin/*
-`,
-			wantHost: "codeberg.org",
-			wantErr:  false,
-		},
-		{
-			name: "SSH URL",
-			gitConfig: `[core]
-	repositoryformatversion = 0
-[remote "origin"]
-	url = git@codeberg.org:owner/repo.git
-	fetch = +refs/heads/*:refs/remotes/origin/*
-`,
-			wantHost: "codeberg.org",
-			wantErr:  false,
-		},
-		{
-			name: "HTTPS URL with port",
-			gitConfig: `[core]
-	repositoryformatversion = 0
-[remote "origin"]
-	url = https://git.example.com:443/owner/repo.git
-	fetch = +refs/heads/*:refs/remotes/origin/*
-`,
-			wantHost: "git.example.com:443",
-			wantErr:  false,
-		},
-		{
-			name: "SSH protocol URL",
-			gitConfig: `[core]
-	repositoryformatversion = 0
-[remote "origin"]
-	url = ssh://git@codeberg.org/owner/repo.git
-	fetch = +refs/heads/*:refs/remotes/origin/*
-`,
-			wantHost: "codeberg.org",
-			wantErr:  false,
-		},
-		{
-			name: "No origin remote",
-			gitConfig: `[core]
-	repositoryformatversion = 0
-[remote "upstream"]
-	url = https://codeberg.org/owner/repo.git
-	fetch = +refs/heads/*:refs/remotes/origin/*
-`,
-			wantHost: "",
-			wantErr:  true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			tmpDir := t.TempDir()
-			gitDir := filepath.Join(tmpDir, ".git")
-			if err := os.MkdirAll(gitDir, 0755); err != nil {
-				t.Fatalf("Failed to create .git directory: %v", err)
-			}
-
-			configPath := filepath.Join(gitDir, "config")
-			if err := os.WriteFile(configPath, []byte(tt.gitConfig), 0644); err != nil {
-				t.Fatalf("Failed to write git config: %v", err)
-			}
-
-			oldWd, err := os.Getwd()
-			if err != nil {
-				t.Fatalf("Failed to get current directory: %v", err)
-			}
-			defer func() {
-				if err := os.Chdir(oldWd); err != nil {
-					t.Logf("Failed to change directory back: %v", err)
-				}
-			}()
-
-			if err := os.Chdir(tmpDir); err != nil {
-				t.Fatalf("Failed to change to temp directory: %v", err)
-			}
-
-			host, err := DetectHost()
-			if (err != nil) != tt.wantErr {
-				t.Errorf("DetectHost() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !tt.wantErr && host != tt.wantHost {
-				t.Errorf("DetectHost() host = %v, want %v", host, tt.wantHost)
 			}
 		})
 	}
diff --git a/internal/iostreams/color.go b/internal/iostreams/color.go
deleted file mode 100644
index 43a5475..0000000
--- a/internal/iostreams/color.go
+++ /dev/null
@@ -1,77 +0,0 @@
-package iostreams
-
-import "fmt"
-
-// ColorScheme provides semantic color methods that respect whether color output is enabled.
-type ColorScheme struct {
-	enabled bool
-}
-
-// NewColorScheme creates a ColorScheme. When enabled is false, all methods return
-// undecorated text.
-func NewColorScheme(enabled bool) *ColorScheme {
-	return &ColorScheme{enabled: enabled}
-}
-
-// colorize wraps text in ANSI escape codes if color is enabled.
-func (cs *ColorScheme) colorize(code string, text string) string {
-	if !cs.enabled {
-		return text
-	}
-	return fmt.Sprintf("\033[%sm%s\033[0m", code, text)
-}
-
-// Bold renders text in bold.
-func (cs *ColorScheme) Bold(s string) string {
-	return cs.colorize("1", s)
-}
-
-// Red renders text in red.
-func (cs *ColorScheme) Red(s string) string {
-	return cs.colorize("31", s)
-}
-
-// Green renders text in green.
-func (cs *ColorScheme) Green(s string) string {
-	return cs.colorize("32", s)
-}
-
-// Yellow renders text in yellow.
-func (cs *ColorScheme) Yellow(s string) string {
-	return cs.colorize("33", s)
-}
-
-// Cyan renders text in cyan.
-func (cs *ColorScheme) Cyan(s string) string {
-	return cs.colorize("36", s)
-}
-
-// Magenta renders text in magenta.
-func (cs *ColorScheme) Magenta(s string) string {
-	return cs.colorize("35", s)
-}
-
-// Muted renders text in gray (dimmed).
-func (cs *ColorScheme) Muted(s string) string {
-	return cs.colorize("90", s)
-}
-
-// SuccessIcon returns a green check mark if color is enabled, plain otherwise.
-func (cs *ColorScheme) SuccessIcon() string {
-	return cs.Green("✓")
-}
-
-// WarningIcon returns a yellow exclamation mark if color is enabled, plain otherwise.
-func (cs *ColorScheme) WarningIcon() string {
-	return cs.Yellow("!")
-}
-
-// FailureIcon returns a red X mark if color is enabled, plain otherwise.
-func (cs *ColorScheme) FailureIcon() string {
-	return cs.Red("✗")
-}
-
-// SuccessIconWithColor returns the success icon followed by the message in green.
-func (cs *ColorScheme) SuccessIconWithColor(msg string) string {
-	return cs.SuccessIcon() + " " + cs.Green(msg)
-}
diff --git a/internal/iostreams/iostreams.go b/internal/iostreams/iostreams.go
deleted file mode 100644
index 8e6528b..0000000
--- a/internal/iostreams/iostreams.go
+++ /dev/null
@@ -1,275 +0,0 @@
-package iostreams
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"os"
-	"os/exec"
-	"runtime"
-	"strings"
-	"sync"
-	"time"
-
-	"golang.org/x/term"
-)
-
-// IOStreams provides the standard streams for the CLI along with TTY detection,
-// color support, pager integration, and other terminal helpers.
-type IOStreams struct {
-	In     io.Reader
-	Out    io.Writer
-	ErrOut io.Writer
-
-	// Private fields for state
-	isStdinTTY  bool
-	isStdoutTTY bool
-	isStderrTTY bool
-
-	pagerProcess *exec.Cmd
-	pagerPipe    io.WriteCloser
-	originalOut  io.Writer
-
-	colorScheme *ColorScheme
-
-	spinnerMu     sync.Mutex
-	spinnerCancel chan struct{}
-}
-
-// New creates an IOStreams wired to the real os.Stdin, os.Stdout, and os.Stderr,
-// with TTY status auto-detected. Setting FJ_FORCE_TTY=1 (or legacy FGJ_FORCE_TTY=1)
-// forces all streams to be treated as TTYs.
-func New() *IOStreams {
-	forceTTY := os.Getenv("FJ_FORCE_TTY") != "" || os.Getenv("FGJ_FORCE_TTY") != ""
-
-	stdinTTY := forceTTY || (isTerminal(os.Stdin.Fd()))
-	stdoutTTY := forceTTY || (isTerminal(os.Stdout.Fd()))
-	stderrTTY := forceTTY || (isTerminal(os.Stderr.Fd()))
-
-	return &IOStreams{
-		In:          os.Stdin,
-		Out:         os.Stdout,
-		ErrOut:      os.Stderr,
-		isStdinTTY:  stdinTTY,
-		isStdoutTTY: stdoutTTY,
-		isStderrTTY: stderrTTY,
-	}
-}
-
-// Test creates an IOStreams backed by bytes.Buffers, suitable for unit tests.
-// All TTY flags are false.
-func Test() *IOStreams {
-	return &IOStreams{
-		In:          &bytes.Buffer{},
-		Out:         &bytes.Buffer{},
-		ErrOut:      &bytes.Buffer{},
-		isStdinTTY:  false,
-		isStdoutTTY: false,
-		isStderrTTY: false,
-	}
-}
-
-// IsStdinTTY reports whether standard input is connected to a terminal.
-func (s *IOStreams) IsStdinTTY() bool {
-	return s.isStdinTTY
-}
-
-// IsStdoutTTY reports whether standard output is connected to a terminal.
-func (s *IOStreams) IsStdoutTTY() bool {
-	return s.isStdoutTTY
-}
-
-// IsStderrTTY reports whether standard error is connected to a terminal.
-func (s *IOStreams) IsStderrTTY() bool {
-	return s.isStderrTTY
-}
-
-// TerminalWidth returns the width of the terminal connected to stdout. If stdout
-// is not a terminal, it returns 80.
-func (s *IOStreams) TerminalWidth() int {
-	if !s.isStdoutTTY {
-		return 80
-	}
-	if f, ok := s.Out.(*os.File); ok {
-		w, _, err := term.GetSize(int(f.Fd()))
-		if err == nil && w > 0 {
-			return w
-		}
-	}
-	return 80
-}
-
-// ColorEnabled returns true when color output should be used. Color is enabled
-// when stdout is a TTY and the NO_COLOR environment variable is not set.
-func (s *IOStreams) ColorEnabled() bool {
-	if os.Getenv("NO_COLOR") != "" {
-		return false
-	}
-	return s.isStdoutTTY
-}
-
-// ColorScheme returns a lazily-initialized ColorScheme that respects the current
-// color settings.
-func (s *IOStreams) ColorScheme() *ColorScheme {
-	if s.colorScheme == nil {
-		s.colorScheme = NewColorScheme(s.ColorEnabled())
-	}
-	return s.colorScheme
-}
-
-// StartPager starts an external pager process and redirects Out to its stdin.
-// It checks FJ_PAGER (or legacy FGJ_PAGER), then PAGER, then defaults to "less".
-// If LESS is not already set, it is set to "FRX" for a good default experience.
-func (s *IOStreams) StartPager() error {
-	if !s.isStdoutTTY {
-		return nil
-	}
-
-	pagerCmd := os.Getenv("FJ_PAGER")
-	if pagerCmd == "" {
-		pagerCmd = os.Getenv("FGJ_PAGER")
-	}
-	if pagerCmd == "" {
-		pagerCmd = os.Getenv("PAGER")
-	}
-	if pagerCmd == "" {
-		pagerCmd = "less"
-	}
-
-	if os.Getenv("LESS") == "" {
-		os.Setenv("LESS", "FRX")
-	}
-
-	parts := strings.Fields(pagerCmd)
-	//nolint:gosec // pager command is user-configured
-	cmd := exec.Command(parts[0], parts[1:]...)
-	cmd.Stdout = s.Out
-	cmd.Stderr = s.ErrOut
-
-	pipe, err := cmd.StdinPipe()
-	if err != nil {
-		return fmt.Errorf("creating pager pipe: %w", err)
-	}
-
-	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("starting pager: %w", err)
-	}
-
-	s.pagerProcess = cmd
-	s.pagerPipe = pipe
-	s.originalOut = s.Out
-	s.Out = pipe
-
-	return nil
-}
-
-// StopPager closes the pager's stdin pipe and waits for the process to exit.
-// It restores Out to the original writer.
-func (s *IOStreams) StopPager() {
-	if s.pagerPipe == nil {
-		return
-	}
-
-	_ = s.pagerPipe.Close()
-	_ = s.pagerProcess.Wait()
-
-	s.Out = s.originalOut
-	s.pagerPipe = nil
-	s.pagerProcess = nil
-	s.originalOut = nil
-}
-
-// spinnerFrames are the Braille-based animation frames for the spinner.
-var spinnerFrames = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
-
-// StartSpinner shows an animated spinner with the given label on stderr. It only
-// runs when stderr is a TTY. Call StopSpinner to halt it.
-func (s *IOStreams) StartSpinner(label string) {
-	if !s.isStderrTTY {
-		return
-	}
-
-	s.spinnerMu.Lock()
-	defer s.spinnerMu.Unlock()
-
-	// Stop any existing spinner first.
-	if s.spinnerCancel != nil {
-		close(s.spinnerCancel)
-		s.spinnerCancel = nil
-	}
-
-	cancel := make(chan struct{})
-	s.spinnerCancel = cancel
-
-	go func() {
-		ticker := time.NewTicker(80 * time.Millisecond)
-		defer ticker.Stop()
-
-		i := 0
-		for {
-			select {
-			case <-cancel:
-				// Clear the spinner line.
-				fmt.Fprintf(s.ErrOut, "\r\033[K")
-				return
-			case <-ticker.C:
-				frame := spinnerFrames[i%len(spinnerFrames)]
-				fmt.Fprintf(s.ErrOut, "\r%s %s", frame, label)
-				i++
-			}
-		}
-	}()
-}
-
-// StopSpinner halts the spinner and clears the line on stderr.
-func (s *IOStreams) StopSpinner() {
-	s.spinnerMu.Lock()
-	defer s.spinnerMu.Unlock()
-
-	if s.spinnerCancel != nil {
-		close(s.spinnerCancel)
-		s.spinnerCancel = nil
-	}
-}
-
-// OpenInBrowser opens the given URL in the user's default browser.
-func (s *IOStreams) OpenInBrowser(url string) error {
-	var cmd *exec.Cmd
-	switch runtime.GOOS {
-	case "darwin":
-		cmd = exec.Command("open", url)
-	case "windows":
-		cmd = exec.Command("cmd", "/c", "start", url)
-	default: // linux, freebsd, etc.
-		cmd = exec.Command("xdg-open", url)
-	}
-	return cmd.Start()
-}
-
-// ConfirmAction prompts the user with a yes/no question and returns their
-// answer. It returns an error if stdin is not a TTY (non-interactive).
-func (s *IOStreams) ConfirmAction(prompt string) (bool, error) {
-	if !s.isStdinTTY {
-		return false, fmt.Errorf("cannot prompt for confirmation: not an interactive terminal")
-	}
-
-	fmt.Fprintf(s.ErrOut, "%s [y/N]: ", prompt)
-
-	var response string
-	if _, err := fmt.Fscan(s.In, &response); err != nil {
-		return false, fmt.Errorf("reading response: %w", err)
-	}
-
-	response = strings.ToLower(strings.TrimSpace(response))
-	return response == "y" || response == "yes", nil
-}
-
-// NewTablePrinter creates a TablePrinter that writes to this IOStreams' output.
-func (s *IOStreams) NewTablePrinter() *TablePrinter {
-	return NewTablePrinter(s)
-}
-
-// isTerminal reports whether the given file descriptor is a terminal.
-func isTerminal(fd uintptr) bool {
-	return term.IsTerminal(int(fd))
-}
diff --git a/internal/iostreams/table.go b/internal/iostreams/table.go
deleted file mode 100644
index a97f711..0000000
--- a/internal/iostreams/table.go
+++ /dev/null
@@ -1,64 +0,0 @@
-package iostreams
-
-import (
-	"fmt"
-	"strings"
-	"text/tabwriter"
-)
-
-// TablePrinter prints TTY-aware tables. In TTY mode it uses aligned columns with
-// bold headers. In pipe mode it emits tab-separated values without headers.
-type TablePrinter struct {
-	ios     *IOStreams
-	headers []string
-	rows    [][]string
-}
-
-// NewTablePrinter creates a TablePrinter that writes to ios.Out.
-func NewTablePrinter(ios *IOStreams) *TablePrinter {
-	return &TablePrinter{
-		ios: ios,
-	}
-}
-
-// AddHeader sets the column headers. Headers are only displayed in TTY mode.
-func (t *TablePrinter) AddHeader(headers ...string) {
-	t.headers = headers
-}
-
-// AddRow appends a row of fields to the table.
-func (t *TablePrinter) AddRow(fields ...string) {
-	t.rows = append(t.rows, fields)
-}
-
-// Render writes the table to the IOStreams output. In TTY mode it uses tabwriter
-// with bold headers. In pipe mode it emits tab-separated values without headers.
-func (t *TablePrinter) Render() error {
-	if !t.ios.IsStdoutTTY() {
-		// Pipe mode: tab-separated, no headers
-		for _, row := range t.rows {
-			if _, err := fmt.Fprintln(t.ios.Out, strings.Join(row, "\t")); err != nil {
-				return err
-			}
-		}
-		return nil
-	}
-
-	// TTY mode: use tabwriter with aligned columns
-	w := tabwriter.NewWriter(t.ios.Out, 0, 0, 2, ' ', 0)
-
-	if len(t.headers) > 0 {
-		cs := t.ios.ColorScheme()
-		boldHeaders := make([]string, len(t.headers))
-		for i, h := range t.headers {
-			boldHeaders[i] = cs.Bold(h)
-		}
-		fmt.Fprintln(w, strings.Join(boldHeaders, "\t"))
-	}
-
-	for _, row := range t.rows {
-		fmt.Fprintln(w, strings.Join(row, "\t"))
-	}
-
-	return w.Flush()
-}
diff --git a/internal/text/text.go b/internal/text/text.go
deleted file mode 100644
index 06e631c..0000000
--- a/internal/text/text.go
+++ /dev/null
@@ -1,70 +0,0 @@
-package text
-
-import (
-	"fmt"
-	"math"
-	"time"
-)
-
-// Pluralize returns "1 issue" or "2 issues" depending on count.
-// It applies a simple "s" suffix rule.
-func Pluralize(count int, singular string) string {
-	if count == 1 {
-		return fmt.Sprintf("%d %s", count, singular)
-	}
-	return fmt.Sprintf("%d %ss", count, singular)
-}
-
-// FuzzyAgo returns a human-friendly relative time string like "just now",
-// "2 minutes ago", "3 hours ago", etc.
-func FuzzyAgo(t time.Time) string {
-	d := time.Since(t)
-
-	if d < time.Minute {
-		return "just now"
-	}
-
-	minutes := int(math.Floor(d.Minutes()))
-	if minutes < 60 {
-		return fmt.Sprintf("%s ago", Pluralize(minutes, "minute"))
-	}
-
-	hours := int(math.Floor(d.Hours()))
-	if hours < 24 {
-		return fmt.Sprintf("%s ago", Pluralize(hours, "hour"))
-	}
-
-	days := hours / 24
-	if days < 30 {
-		return fmt.Sprintf("%s ago", Pluralize(days, "day"))
-	}
-
-	months := days / 30
-	if months < 12 {
-		return fmt.Sprintf("%s ago", Pluralize(months, "month"))
-	}
-
-	years := months / 12
-	return fmt.Sprintf("%s ago", Pluralize(years, "year"))
-}
-
-// Truncate shortens text to maxWidth, replacing the end with "..." if it exceeds
-// the limit. If maxWidth is less than or equal to 3, the result is just "...".
-func Truncate(text string, maxWidth int) string {
-	if len(text) <= maxWidth {
-		return text
-	}
-	if maxWidth <= 3 {
-		return "..."[:maxWidth]
-	}
-	return text[:maxWidth-3] + "..."
-}
-
-// FormatDate returns a human-friendly relative time for TTY output, or an
-// RFC3339 timestamp for piped output.
-func FormatDate(t time.Time, isTTY bool) string {
-	if isTTY {
-		return FuzzyAgo(t)
-	}
-	return t.Format(time.RFC3339)
-}
diff --git a/main.go b/main.go
index 1c4f378..4e596a3 100644
--- a/main.go
+++ b/main.go
@@ -4,17 +4,12 @@ import (
 	"fmt"
 	"os"
 
-	"forgejo.zerova.net/public/fj/cmd"
+	"codeberg.org/romaintb/fgj/cmd"
 )
 
 func main() {
 	if err := cmd.Execute(); err != nil {
-		err = cmd.ContextualError(err)
-		if cmd.JSONErrors() {
-			cmd.WriteJSONError(err)
-		} else {
-			fmt.Fprintln(os.Stderr, err)
-		}
+		fmt.Fprintln(os.Stderr, err)
 		os.Exit(1)
 	}
 }
diff --git a/tests/functional/fixtures.go b/tests/functional/fixtures.go
index ec6b72d..80621ab 100644
--- a/tests/functional/fixtures.go
+++ b/tests/functional/fixtures.go
@@ -9,7 +9,6 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"strings"
 	"testing"
 
 	"code.gitea.io/sdk/gitea"
@@ -152,94 +151,15 @@ func (env *TestEnv) VerifyAPIConnection() {
 	}
 }
 
-// EnsureTestLabels creates test labels if they don't exist
-func (env *TestEnv) EnsureTestLabels() {
-	labelNames := []string{"bug", "enhancement", "help-wanted"}
-
-	for _, name := range labelNames {
-		labels, _, err := env.Client.ListRepoLabels(env.Owner, env.RepoName, gitea.ListLabelsOptions{})
-		if err != nil {
-			env.T.Fatalf("failed to list labels: %v", err)
-		}
-
-		exists := false
-		for _, label := range labels {
-			if label.Name == name {
-				exists = true
-				break
-			}
-		}
-
-		if !exists {
-			color := "#00aabb"
-			if name == "bug" {
-				color = "#ff0000"
-			} else if name == "enhancement" {
-				color = "#00ff00"
-			}
-			_, _, err = env.Client.CreateLabel(env.Owner, env.RepoName, gitea.CreateLabelOption{
-				Name:  name,
-				Color: color,
-			})
-			if err != nil {
-				env.T.Logf("warning: failed to create label '%s': %v", name, err)
-			} else {
-				env.T.Logf("Created test label: %s", name)
-			}
-		}
-	}
-}
-
-// GetIssueLabels gets the labels on an issue
-func (env *TestEnv) GetIssueLabels(issueNumber int64) ([]*gitea.Label, error) {
-	labels, _, err := env.Client.GetIssueLabels(env.Owner, env.RepoName, issueNumber, gitea.ListLabelsOptions{})
-	return labels, err
-}
-
-// GetLabelIDs converts label names to label IDs
-func (env *TestEnv) GetLabelIDs(labelNames []string) []int64 {
-	labels, _, err := env.Client.ListRepoLabels(env.Owner, env.RepoName, gitea.ListLabelsOptions{})
-	if err != nil {
-		env.T.Fatalf("failed to list labels: %v", err)
-	}
-
-	nameToID := make(map[string]int64)
-	for _, label := range labels {
-		nameToID[label.Name] = label.ID
-	}
-
-	var ids []int64
-	for _, name := range labelNames {
-		id, exists := nameToID[name]
-		if !exists {
-			env.T.Fatalf("label '%s' not found", name)
-		}
-		ids = append(ids, id)
-	}
-
-	return ids
-}
-
-// CleanupRepo deletes a repository created during testing.
-func (env *TestEnv) CleanupRepo(owner, repoName string) {
-	_, err := env.Client.DeleteRepo(owner, repoName)
-	if err != nil {
-		env.T.Logf("warning: failed to delete repo %s/%s: %v", owner, repoName, err)
-	}
-}
-
-// GetBinaryPath returns the path to the built fj binary
+// GetBinaryPath returns the path to the built fgj binary
 func (env *TestEnv) GetBinaryPath() string {
-	binaryPath := os.Getenv("FJ_BINARY_PATH")
-	if binaryPath == "" {
-		binaryPath = os.Getenv("FGJ_BINARY_PATH")
-	}
+	binaryPath := os.Getenv("FGJ_BINARY_PATH")
 	if binaryPath == "" {
 		// Look for the binary in common locations
 		candidates := []string{
-			"./bin/fj",
-			"bin/fj",
-			"/home/romain/work/fj/bin/fj",
+			"./bin/fgj",
+			"bin/fgj",
+			"/home/romain/work/fgj/bin/fgj",
 		}
 		for _, candidate := range candidates {
 			if _, err := os.Stat(candidate); err == nil {
@@ -251,7 +171,7 @@ func (env *TestEnv) GetBinaryPath() string {
 			}
 		}
 		// If no binary found, return default (will error when executed)
-		binaryPath = "./bin/fj"
+		binaryPath = "./bin/fgj"
 	}
 	return binaryPath
 }
@@ -299,39 +219,3 @@ func (env *TestEnv) RunCLI(args ...string) *CLIResult {
 
 	return result
 }
-
-// runCLIWithStdin executes the CLI binary with the given args and pipes input to stdin.
-func (env *TestEnv) runCLIWithStdin(input string, args ...string) *CLIResult {
-	cmd := exec.Command(env.GetBinaryPath(), args...)
-	cmd.Env = os.Environ()
-	cmd.Stdin = strings.NewReader(input)
-
-	var stdout, stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-
-	err := cmd.Run()
-	exitCode := 0
-	if err != nil {
-		if exitErr, ok := err.(*exec.ExitError); ok {
-			exitCode = exitErr.ExitCode()
-		}
-	}
-
-	result := &CLIResult{
-		Stdout:   stdout.String(),
-		Stderr:   stderr.String(),
-		ExitCode: exitCode,
-	}
-
-	env.T.Logf("Command: %s %v", env.GetBinaryPath(), args)
-	env.T.Logf("Exit code: %d", exitCode)
-	if stdout.Len() > 0 {
-		env.T.Logf("Stdout:\n%s", result.Stdout)
-	}
-	if stderr.Len() > 0 {
-		env.T.Logf("Stderr:\n%s", result.Stderr)
-	}
-
-	return result
-}
diff --git a/tests/functional/functional_test.go b/tests/functional/functional_test.go
index 740cde3..73f098c 100644
--- a/tests/functional/functional_test.go
+++ b/tests/functional/functional_test.go
@@ -1,27 +1,23 @@
-//go:build functional
 // +build functional
 
 package functional
 
 import (
 	"bytes"
-	"encoding/json"
 	"fmt"
 	"os"
-	"strings"
 	"testing"
-	"time"
 
 	"code.gitea.io/sdk/gitea"
 )
 
-// ===== SDK API tests (verify test environment and API connectivity) =====
-
+// TestAPIConnection verifies we can connect to the Codeberg API with the test account
 func TestAPIConnection(t *testing.T) {
 	env := NewTestEnv(t)
 	env.VerifyAPIConnection()
 }
 
+// TestListRepositories verifies we can list repositories
 func TestListRepositories(t *testing.T) {
 	env := NewTestEnv(t)
 
@@ -36,6 +32,7 @@ func TestListRepositories(t *testing.T) {
 
 	t.Logf("Found %d repositories", len(repos))
 
+	// Verify we can find our test repo
 	found := false
 	for _, repo := range repos {
 		if repo.Name == env.RepoName {
@@ -50,6 +47,7 @@ func TestListRepositories(t *testing.T) {
 	}
 }
 
+// TestGetRepository verifies we can get repository details
 func TestGetRepository(t *testing.T) {
 	env := NewTestEnv(t)
 
@@ -69,9 +67,125 @@ func TestGetRepository(t *testing.T) {
 	t.Logf("Repository: %s (%s)", repo.FullName, repo.Description)
 }
 
+// TestCreateAndListIssues verifies we can create and list issues
+func TestCreateAndListIssues(t *testing.T) {
+	env := NewTestEnv(t)
+
+	// Create a test issue
+	issueNum := env.CreateTestIssue(
+		"[FGJ E2E Test] Test Issue",
+		"This is a functional test issue for fgj",
+	)
+
+	defer env.CleanupIssue(issueNum)
+
+	// List issues
+	issues, _, err := env.Client.ListRepoIssues(env.Owner, env.RepoName, gitea.ListIssueOption{})
+	if err != nil {
+		t.Fatalf("failed to list issues: %v", err)
+	}
+
+	// Verify our created issue is in the list
+	found := false
+	for _, issue := range issues {
+		if issue.Index == issueNum {
+			found = true
+			break
+		}
+	}
+
+	if !found {
+		t.Fatalf("created issue #%d not found in issue list", issueNum)
+	}
+
+	t.Logf("Successfully created and listed issue #%d", issueNum)
+}
+
+// TestGetIssue verifies we can get issue details
+func TestGetIssue(t *testing.T) {
+	env := NewTestEnv(t)
+
+	// Create a test issue
+	issueNum := env.CreateTestIssue(
+		"[FGJ E2E Test] Get Issue Test",
+		"Testing get issue functionality",
+	)
+
+	defer env.CleanupIssue(issueNum)
+
+	// Get the issue
+	issue, _, err := env.Client.GetIssue(env.Owner, env.RepoName, issueNum)
+	if err != nil {
+		t.Fatalf("failed to get issue: %v", err)
+	}
+
+	if issue.Index != issueNum {
+		t.Fatalf("expected issue number %d, got %d", issueNum, issue.Index)
+	}
+
+	if issue.Title != "[FGJ E2E Test] Get Issue Test" {
+		t.Fatalf("issue title mismatch")
+	}
+
+	t.Logf("Retrieved issue #%d: %s", issueNum, issue.Title)
+}
+
+// TestCommentOnIssue verifies we can comment on issues
+func TestCommentOnIssue(t *testing.T) {
+	env := NewTestEnv(t)
+
+	// Create a test issue
+	issueNum := env.CreateTestIssue(
+		"[FGJ E2E Test] Comment Test",
+		"Testing comment functionality",
+	)
+
+	defer env.CleanupIssue(issueNum)
+
+	// Add a comment
+	comment, _, err := env.Client.CreateIssueComment(
+		env.Owner,
+		env.RepoName,
+		issueNum,
+		gitea.CreateIssueCommentOption{
+			Body: "This is an automated test comment from fgj functional tests",
+		},
+	)
+	if err != nil {
+		t.Fatalf("failed to create issue comment: %v", err)
+	}
+
+	if comment.Body != "This is an automated test comment from fgj functional tests" {
+		t.Fatalf("comment body mismatch")
+	}
+
+	t.Logf("Successfully added comment to issue #%d", issueNum)
+}
+
+// TestGetRepositoryWithCollaborators verifies we can get repo and check collaborators
+func TestGetRepositoryWithCollaborators(t *testing.T) {
+	env := NewTestEnv(t)
+
+	// Get repository with full details
+	repo, _, err := env.Client.GetRepo(env.Owner, env.RepoName)
+	if err != nil {
+		t.Fatalf("failed to get repository: %v", err)
+	}
+
+	// Verify basic repo properties
+	if repo.FullName != env.Owner+"/"+env.RepoName {
+		t.Fatalf("expected repo full name %s/%s, got %s", env.Owner, env.RepoName, repo.FullName)
+	}
+
+	t.Logf("Repository %s has %d watchers, %d stars, %d forks",
+		repo.FullName, repo.Watchers, repo.Stars, repo.Forks)
+}
+
+// TestAPIErrorHandling verifies proper error handling for invalid requests
 func TestAPIErrorHandling(t *testing.T) {
 	env := NewTestEnv(t)
 
+	// Try to get a non-existent issue
 	_, _, err := env.Client.GetIssue(env.Owner, env.RepoName, 999999)
 	if err == nil {
 		t.Fatalf("expected error for non-existent issue, got none")
@@ -80,252 +194,102 @@ func TestAPIErrorHandling(t *testing.T) {
 	t.Logf("Properly handled error: %v", err)
 }
 
-// ===== CLI Issue Commands =====
-
-func TestCLIIssueList(t *testing.T) {
+// TestRepositoryExists verifies the test repository exists and is accessible
+func TestRepositoryExists(t *testing.T) {
 	env := NewTestEnv(t)
 
-	// Create a test issue so the list is not empty
-	issueNum := env.CreateTestIssue("[FJ E2E Test] Issue List", "For issue list test")
-	defer env.CleanupIssue(issueNum)
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"issue", "list",
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("issue list failed with exit code %d: %s", result.ExitCode, result.Stderr)
+	repo, _, err := env.Client.GetRepo(env.Owner, env.RepoName)
+	if err != nil {
+		t.Fatalf("test repository does not exist or is not accessible: %v", err)
 	}
 
-	if !strings.Contains(result.Stdout, "Issue List") {
-		t.Fatalf("expected issue list output to contain our test issue, got: %s", result.Stdout)
+	if repo.Private {
+		t.Logf("Test repository is private: %s", repo.FullName)
+	} else {
+		t.Logf("Test repository is public: %s", repo.FullName)
 	}
-
-	t.Logf("Successfully listed issues via CLI")
 }
 
-func TestCLIIssueListJSON(t *testing.T) {
-	env := NewTestEnv(t)
-
-	issueNum := env.CreateTestIssue("[FJ E2E Test] JSON List", "For JSON output test")
-	defer env.CleanupIssue(issueNum)
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"issue", "list", "--json",
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("issue list --json failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	var issues []interface{}
-	if err := json.Unmarshal([]byte(result.Stdout), &issues); err != nil {
-		t.Fatalf("failed to parse JSON output: %v\nOutput: %s", err, result.Stdout)
-	}
-
-	if len(issues) == 0 {
-		t.Fatalf("expected at least one issue in JSON output")
-	}
-
-	t.Logf("Successfully listed %d issues via CLI with --json", len(issues))
-}
-
-func TestCLIIssueView(t *testing.T) {
-	env := NewTestEnv(t)
-
-	issueNum := env.CreateTestIssue("[FJ E2E Test] View Test", "Testing issue view")
-	defer env.CleanupIssue(issueNum)
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"issue", "view", fmt.Sprintf("%d", issueNum),
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("issue view failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	if !strings.Contains(result.Stdout, "View Test") {
-		t.Fatalf("expected issue view output to contain title, got: %s", result.Stdout)
-	}
-
-	t.Logf("Successfully viewed issue #%d via CLI", issueNum)
-}
-
-func TestCLIIssueViewJSON(t *testing.T) {
-	env := NewTestEnv(t)
-
-	issueNum := env.CreateTestIssue("[FJ E2E Test] JSON View", "Testing JSON view")
-	defer env.CleanupIssue(issueNum)
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"issue", "view", fmt.Sprintf("%d", issueNum), "--json",
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("issue view --json failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	var data map[string]interface{}
-	if err := json.Unmarshal([]byte(result.Stdout), &data); err != nil {
-		t.Fatalf("failed to parse JSON output: %v\nOutput: %s", err, result.Stdout)
-	}
-
-	// issue view --json wraps the issue in an "issue" key
-	issueObj, _ := data["issue"].(map[string]interface{})
-	if issueObj == nil {
-		// fallback: maybe it's flat
-		issueObj = data
-	}
-	if title, ok := issueObj["title"].(string); !ok || !strings.Contains(title, "JSON View") {
-		t.Fatalf("expected title containing 'JSON View' in JSON output, got: %v", issueObj["title"])
-	}
-
-	t.Logf("Successfully viewed issue #%d via CLI with --json", issueNum)
-}
+// ===== CLI COMMAND TESTS =====
 
+// TestCLIIssueCreate verifies the `fgj issue create` command works (via API, not CLI)
+// Note: CLI requires proper config setup which is tested via API tests
 func TestCLIIssueCreate(t *testing.T) {
 	env := NewTestEnv(t)
 
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"issue", "create",
-		"-t", "[FJ E2E Test] CLI Created Issue",
-		"-b", "Created directly via fj CLI",
+	// Use API directly since CLI requires config file for auth
+	issueNum := env.CreateTestIssue(
+		"[FGJ CLI Test] Created via API",
+		"This issue was created using the API (CLI test proxy)",
 	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("issue create failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	var issueNum int64
-	for _, line := range strings.Split(strings.TrimSpace(result.Stdout), "\n") {
-		if _, err := fmt.Sscanf(line, "Issue created: #%d", &issueNum); err == nil {
-			break
-		}
-	}
-	if issueNum == 0 {
-		t.Fatalf("failed to parse issue number from output: %s", result.Stdout)
-	}
-
-	defer env.CleanupIssue(issueNum)
-	t.Logf("Successfully created issue #%d via CLI", issueNum)
-}
-
-func TestCLIIssueCreateWithLabels(t *testing.T) {
-	env := NewTestEnv(t)
-
-	env.EnsureTestLabels()
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"issue", "create",
-		"-t", "[FJ E2E Test] Issue with Labels",
-		"-b", "This issue was created with labels",
-		"-l", "bug",
-		"-l", "enhancement",
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("issue create with labels failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	var issueNum int64
-	for _, line := range strings.Split(strings.TrimSpace(result.Stdout), "\n") {
-		if _, err := fmt.Sscanf(line, "Issue created: #%d", &issueNum); err == nil {
-			break
-		}
-	}
-	if issueNum == 0 {
-		t.Fatalf("failed to parse issue number from output: %s", result.Stdout)
-	}
-
 	defer env.CleanupIssue(issueNum)
 
-	labels, err := env.GetIssueLabels(issueNum)
+	// Verify the issue was created
+	issue, _, err := env.Client.GetIssue(env.Owner, env.RepoName, issueNum)
 	if err != nil {
-		t.Fatalf("failed to get issue labels: %v", err)
+		t.Fatalf("failed to get created issue: %v", err)
 	}
 
-	if len(labels) != 2 {
-		t.Fatalf("expected 2 labels, got %d", len(labels))
+	if issue.Title != "[FGJ CLI Test] Created via API" {
+		t.Fatalf("issue title mismatch")
 	}
 
-	labelNames := make(map[string]bool)
-	for _, label := range labels {
-		labelNames[label.Name] = true
-	}
-
-	if !labelNames["bug"] || !labelNames["enhancement"] {
-		t.Fatalf("expected labels 'bug' and 'enhancement', got %v", labelNames)
-	}
-
-	t.Logf("Successfully created issue #%d with labels: bug, enhancement", issueNum)
+	t.Logf("Successfully tested issue create via API for CLI #%d", issueNum)
 }
 
+// TestCLIIssueComment verifies the `fgj issue comment` command works (via API, not CLI)
+// Note: CLI requires proper config setup which is tested via API tests
 func TestCLIIssueComment(t *testing.T) {
 	env := NewTestEnv(t)
 
-	issueNum := env.CreateTestIssue("[FJ E2E Test] Comment Test", "Testing comment via CLI")
+	// Create an issue via API
+	issueNum := env.CreateTestIssue(
+		"[FGJ CLI Test] For commenting",
+		"This issue will receive a comment",
+	)
 	defer env.CleanupIssue(issueNum)
 
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"issue", "comment",
-		fmt.Sprintf("%d", issueNum),
-		"-b", "CLI comment from functional test",
+	// Add comment via API
+	comment, _, err := env.Client.CreateIssueComment(
+		env.Owner,
+		env.RepoName,
+		issueNum,
+		gitea.CreateIssueCommentOption{
+			Body: "This is a test comment",
+		},
 	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("issue comment failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	// Verify comment was added via API
-	comments, _, err := env.Client.ListIssueComments(env.Owner, env.RepoName, issueNum, gitea.ListIssueCommentOptions{})
 	if err != nil {
-		t.Fatalf("failed to list comments: %v", err)
+		t.Fatalf("failed to create comment: %v", err)
 	}
 
-	found := false
-	for _, c := range comments {
-		if c.Body == "CLI comment from functional test" {
-			found = true
-			break
-		}
-	}
-	if !found {
-		t.Fatalf("comment not found on issue #%d", issueNum)
+	if comment.Body != "This is a test comment" {
+		t.Fatalf("comment body mismatch")
 	}
 
-	t.Logf("Successfully commented on issue #%d via CLI", issueNum)
+	t.Logf("Successfully tested issue comment via API for CLI #%d", issueNum)
 }
 
+// TestCLIIssueClose verifies the `fgj issue close` command works (via API, not CLI)
+// Note: CLI requires proper config setup which is tested via API tests
 func TestCLIIssueClose(t *testing.T) {
 	env := NewTestEnv(t)
 
-	issueNum := env.CreateTestIssue("[FJ E2E Test] Close Test", "Will be closed via CLI")
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"issue", "close",
-		fmt.Sprintf("%d", issueNum),
+	// Create an issue via API
+	issueNum := env.CreateTestIssue(
+		"[FGJ CLI Test] For closing",
+		"This issue will be closed",
 	)
 
-	if result.ExitCode != 0 {
-		t.Fatalf("issue close failed with exit code %d: %s", result.ExitCode, result.Stderr)
+	// Close via API
+	closeState := gitea.StateClosed
+	_, _, err := env.Client.EditIssue(env.Owner, env.RepoName, issueNum, gitea.EditIssueOption{
+		State: &closeState,
+	})
+	if err != nil {
+		t.Fatalf("failed to close issue: %v", err)
 	}
 
+	// Verify the issue was closed
 	issue, _, err := env.Client.GetIssue(env.Owner, env.RepoName, issueNum)
 	if err != nil {
 		t.Fatalf("failed to get issue: %v", err)
@@ -335,187 +299,16 @@ func TestCLIIssueClose(t *testing.T) {
 		t.Fatalf("expected issue state 'closed', got '%s'", issue.State)
 	}
 
-	t.Logf("Successfully closed issue #%d via CLI", issueNum)
+	t.Logf("Successfully tested issue close via API for CLI #%d", issueNum)
 }
 
-func TestCLIIssueCloseWithComment(t *testing.T) {
-	env := NewTestEnv(t)
-
-	issueNum := env.CreateTestIssue("[FJ E2E Test] Close with comment", "Will be closed with a comment")
-
-	commentText := "Fixed in v2.0 - closing via functional test"
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"issue", "close",
-		fmt.Sprintf("%d", issueNum),
-		"-c", commentText,
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("issue close -c failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	issue, _, err := env.Client.GetIssue(env.Owner, env.RepoName, issueNum)
-	if err != nil {
-		t.Fatalf("failed to get issue: %v", err)
-	}
-
-	if issue.State != "closed" {
-		t.Fatalf("expected issue state 'closed', got '%s'", issue.State)
-	}
-
-	comments, _, err := env.Client.ListIssueComments(env.Owner, env.RepoName, issueNum, gitea.ListIssueCommentOptions{})
-	if err != nil {
-		t.Fatalf("failed to list issue comments: %v", err)
-	}
-
-	found := false
-	for _, comment := range comments {
-		if comment.Body == commentText {
-			found = true
-			break
-		}
-	}
-
-	if !found {
-		t.Fatalf("comment '%s' not found in issue comments", commentText)
-	}
-
-	t.Logf("Successfully closed issue #%d with comment via CLI", issueNum)
-}
-
-func TestCLIIssueEditTitle(t *testing.T) {
-	env := NewTestEnv(t)
-
-	issueNum := env.CreateTestIssue("[FJ E2E Test] Original Title", "Will be edited")
-	defer env.CleanupIssue(issueNum)
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"issue", "edit",
-		fmt.Sprintf("%d", issueNum),
-		"-t", "[FJ E2E Test] Updated Title",
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("issue edit failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	issue, _, err := env.Client.GetIssue(env.Owner, env.RepoName, issueNum)
-	if err != nil {
-		t.Fatalf("failed to get issue: %v", err)
-	}
-
-	if issue.Title != "[FJ E2E Test] Updated Title" {
-		t.Fatalf("expected updated title, got '%s'", issue.Title)
-	}
-
-	t.Logf("Successfully edited issue #%d title via CLI", issueNum)
-}
-
-func TestCLIIssueEditAddLabels(t *testing.T) {
-	env := NewTestEnv(t)
-
-	env.EnsureTestLabels()
-
-	issueNum := env.CreateTestIssue("[FJ E2E Test] Add Labels", "Will have labels added")
-	defer env.CleanupIssue(issueNum)
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"issue", "edit",
-		fmt.Sprintf("%d", issueNum),
-		"--add-label", "bug",
-		"--add-label", "help-wanted",
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("issue edit add-label failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	labels, err := env.GetIssueLabels(issueNum)
-	if err != nil {
-		t.Fatalf("failed to get labels after edit: %v", err)
-	}
-
-	if len(labels) != 2 {
-		t.Fatalf("expected 2 labels after edit, got %d", len(labels))
-	}
-
-	labelNames := make(map[string]bool)
-	for _, label := range labels {
-		labelNames[label.Name] = true
-	}
-
-	if !labelNames["bug"] || !labelNames["help-wanted"] {
-		t.Fatalf("expected labels 'bug' and 'help-wanted', got %v", labelNames)
-	}
-
-	t.Logf("Successfully added labels to issue #%d via CLI", issueNum)
-}
-
-func TestCLIIssueEditRemoveLabels(t *testing.T) {
-	env := NewTestEnv(t)
-
-	env.EnsureTestLabels()
-
-	issue, _, err := env.Client.CreateIssue(env.Owner, env.RepoName, gitea.CreateIssueOption{
-		Title: "[FJ E2E Test] Remove Labels",
-		Body:  "Will have labels removed",
-	})
-	if err != nil {
-		t.Fatalf("failed to create issue: %v", err)
-	}
-	defer env.CleanupIssue(issue.Index)
-
-	labelIDs := env.GetLabelIDs([]string{"bug", "enhancement"})
-	_, _, err = env.Client.AddIssueLabels(env.Owner, env.RepoName, issue.Index, gitea.IssueLabelsOption{
-		Labels: labelIDs,
-	})
-	if err != nil {
-		t.Fatalf("failed to add initial labels: %v", err)
-	}
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"issue", "edit",
-		fmt.Sprintf("%d", issue.Index),
-		"--remove-label", "bug",
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("issue edit remove-label failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	labels, err := env.GetIssueLabels(issue.Index)
-	if err != nil {
-		t.Fatalf("failed to get labels after edit: %v", err)
-	}
-
-	if len(labels) != 1 {
-		t.Fatalf("expected 1 label after removal, got %d", len(labels))
-	}
-
-	if labels[0].Name != "enhancement" {
-		t.Fatalf("expected remaining label 'enhancement', got '%s'", labels[0].Name)
-	}
-
-	t.Logf("Successfully removed label from issue #%d via CLI", issue.Index)
-}
-
-// ===== CLI PR Commands =====
-
+// TestCLIPRList verifies the `fgj pr list` command works
 func TestCLIPRList(t *testing.T) {
 	env := NewTestEnv(t)
 
+	// Run: fgj pr list
 	result := env.RunCLI(
 		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
 		"pr", "list",
 	)
 
@@ -523,47 +316,72 @@ func TestCLIPRList(t *testing.T) {
 		t.Fatalf("pr list failed with exit code %d: %s", result.ExitCode, result.Stderr)
 	}
 
+	// pr list should produce output (even if empty)
+	if result.Stdout == "" {
+		t.Logf("Note: pr list produced empty output (no PRs in repo)")
+	} else {
+		t.Logf("pr list output:\n%s", result.Stdout)
+	}
+
+	// Verify we got some output (at least the header or "No pull requests" message)
+	if result.Stdout == "" && result.Stderr == "" {
+		t.Logf("Note: pr list produced no output")
+	}
+
 	t.Logf("Successfully listed pull requests via CLI")
 }
 
-func TestCLIPRListJSON(t *testing.T) {
+// TestCLIActionsRunList verifies the `fgj actions run list` command works
+func TestCLIActionsRunList(t *testing.T) {
 	env := NewTestEnv(t)
 
+	// Run: fgj actions run list
 	result := env.RunCLI(
 		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"pr", "list", "--json",
+		"actions", "run", "list",
 	)
 
+	// Actions might not be enabled, so we accept both success and failure
 	if result.ExitCode != 0 {
-		t.Fatalf("pr list --json failed with exit code %d: %s", result.ExitCode, result.Stderr)
+		if bytes.Contains([]byte(result.Stderr), []byte("Actions")) ||
+			bytes.Contains([]byte(result.Stderr), []byte("not enabled")) ||
+			bytes.Contains([]byte(result.Stderr), []byte("404")) {
+			t.Logf("Note: actions run list not available (Actions may not be enabled): %s", result.Stderr)
+			return
+		}
+		t.Logf("actions run list exited with code %d: %s", result.ExitCode, result.Stderr)
 	}
 
-	var prs []interface{}
-	if err := json.Unmarshal([]byte(result.Stdout), &prs); err != nil {
-		t.Fatalf("failed to parse JSON output: %v\nOutput: %s", err, result.Stdout)
+	if result.Stdout == "" {
+		t.Logf("Note: actions run list produced empty output (no workflow runs)")
+	} else {
+		t.Logf("actions run list output:\n%s", result.Stdout)
 	}
 
-	t.Logf("Successfully listed %d PRs via CLI with --json", len(prs))
+	t.Logf("Successfully listed workflow runs via CLI")
 }
 
+// TestCLIPRView verifies the `fgj pr view` command works
 func TestCLIPRView(t *testing.T) {
 	env := NewTestEnv(t)
 
+	// First, check if there are any PRs in the repository
 	prs, err := env.ListPullRequests()
 	if err != nil {
 		t.Fatalf("failed to list PRs: %v", err)
 	}
 
 	if len(prs) == 0 {
+		t.Logf("Note: No pull requests in test repository, skipping pr view test")
 		t.Skip("No PRs available to view")
 	}
 
+	// Get the first PR number
 	prNumber := prs[0].Index
 
+	// Run: fgj pr view <pr-number>
 	result := env.RunCLI(
 		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
 		"pr", "view",
 		fmt.Sprintf("%d", prNumber),
 	)
@@ -576,652 +394,51 @@ func TestCLIPRView(t *testing.T) {
 		t.Fatalf("pr view produced no output")
 	}
 
+	// Verify output contains PR information
+	if !bytes.Contains([]byte(result.Stdout), []byte(prs[0].Title)) &&
+		!bytes.Contains([]byte(result.Stdout), []byte(fmt.Sprintf("#%d", prNumber))) {
+		t.Logf("Warning: pr view output may not contain expected PR info")
+		t.Logf("Output: %s", result.Stdout)
+	}
+
 	t.Logf("Successfully viewed PR #%d via CLI", prNumber)
 }
 
-func TestCLIPRDiff(t *testing.T) {
-	env := NewTestEnv(t)
-
-	prs, err := env.ListPullRequests()
-	if err != nil {
-		t.Fatalf("failed to list PRs: %v", err)
-	}
-
-	if len(prs) == 0 {
-		t.Skip("No PRs available for diff test")
-	}
-
-	prNumber := prs[0].Index
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"pr", "diff",
-		fmt.Sprintf("%d", prNumber),
-		"--name-only",
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("pr diff failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	if strings.TrimSpace(result.Stdout) == "" {
-		t.Fatalf("pr diff --name-only produced no output")
-	}
-
-	t.Logf("Successfully retrieved diff for PR #%d via CLI", prNumber)
-}
-
-func TestCLIPRComment(t *testing.T) {
-	env := NewTestEnv(t)
-
-	// PRs share the comment API with issues
-	issueNum := env.CreateTestIssue("[FJ E2E Test] PR Comment Test", "Testing pr comment command")
-	defer env.CleanupIssue(issueNum)
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"pr", "comment",
-		fmt.Sprintf("%d", issueNum),
-		"-b", "Automated test comment via fj pr comment",
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("pr comment failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	t.Logf("Successfully commented on issue #%d via fj pr comment", issueNum)
-}
-
-// ===== CLI Repo Commands =====
-
-func TestCLIRepoView(t *testing.T) {
-	env := NewTestEnv(t)
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"repo", "view",
-		fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("repo view failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	if !strings.Contains(result.Stdout, env.RepoName) {
-		t.Fatalf("expected repo name in output, got: %s", result.Stdout)
-	}
-
-	t.Logf("Successfully viewed repo via CLI")
-}
-
-func TestCLIRepoList(t *testing.T) {
-	env := NewTestEnv(t)
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"repo", "list",
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("repo list failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	if !strings.Contains(result.Stdout, env.RepoName) {
-		t.Fatalf("expected test repo in list output, got: %s", result.Stdout)
-	}
-
-	t.Logf("Successfully listed repos via CLI")
-}
-
-func TestCLIRepoCreate(t *testing.T) {
-	env := NewTestEnv(t)
-
-	repoName := fmt.Sprintf("fj-test-create-%d", time.Now().UnixNano())
-	defer env.CleanupRepo(env.Owner, repoName)
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"repo", "create", repoName,
-		"--public",
-		"-d", "Created by fj functional test",
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("repo create failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	if !strings.Contains(result.Stdout, repoName) {
-		t.Fatalf("expected output to contain repo name %q, got: %s", repoName, result.Stdout)
-	}
-
-	repo, _, err := env.Client.GetRepo(env.Owner, repoName)
-	if err != nil {
-		t.Fatalf("repo was not created or not accessible: %v", err)
-	}
-	if repo.Private {
-		t.Fatalf("expected public repo, got private")
-	}
-	if repo.Description != "Created by fj functional test" {
-		t.Fatalf("expected description %q, got %q", "Created by fj functional test", repo.Description)
-	}
-
-	t.Logf("Successfully created repository %s via CLI", repo.FullName)
-}
-
-func TestCLIRepoEdit(t *testing.T) {
-	env := NewTestEnv(t)
-
-	repo, _, err := env.Client.GetRepo(env.Owner, env.RepoName)
-	if err != nil {
-		t.Fatalf("failed to get repo: %v", err)
-	}
-	originalDesc := repo.Description
-
-	defer func() {
-		env.RunCLI(
-			"--hostname", env.Hostname,
-			"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-			"repo", "edit",
-			"-d", originalDesc,
-		)
-	}()
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"repo", "edit",
-		"-d", "Updated description via functional test",
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("repo edit failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	updatedRepo, _, err := env.Client.GetRepo(env.Owner, env.RepoName)
-	if err != nil {
-		t.Fatalf("failed to get repo after edit: %v", err)
-	}
-
-	if updatedRepo.Description != "Updated description via functional test" {
-		t.Fatalf("expected description %q, got %q",
-			"Updated description via functional test", updatedRepo.Description)
-	}
-
-	t.Logf("Successfully edited repo description via CLI")
-}
-
+// TestCLIRepoClone verifies the `fgj repo clone` command works
 func TestCLIRepoClone(t *testing.T) {
 	env := NewTestEnv(t)
 
+	// For repo clone, we test by cloning the current repository (fgj itself)
+	// since that doesn't require special permissions
 	tmpDir := t.TempDir()
-	clonePath := fmt.Sprintf("%s/fj-clone", tmpDir)
+	clonePath := fmt.Sprintf("%s/fgj-clone", tmpDir)
 
+	// Run: fgj repo clone romaintb/fgj <destination>
+	// Using the public fgj repository to avoid auth issues
 	result := env.RunCLI(
 		"--hostname", env.Hostname,
 		"repo", "clone",
-		fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
+		"romaintb/fgj",
 		clonePath,
 	)
 
 	if result.ExitCode != 0 {
+		t.Logf("Note: repo clone failed, which may be due to test environment limitations")
+		t.Logf("Exit code: %d", result.ExitCode)
+		t.Logf("Stderr: %s", result.Stderr)
+		// Skip instead of failing since this might be an auth/config issue in test env
 		t.Skip("repo clone requires full authentication setup")
 	}
 
+	// Verify the repository was cloned
 	gitDir := fmt.Sprintf("%s/.git", clonePath)
 	if _, err := os.Stat(gitDir); err != nil {
 		t.Logf("Warning: .git directory not found, clone may not have completed")
+		t.Logf("Stdout: %s", result.Stdout)
+		// Don't fail - just note that clone didn't complete
+		// This might be expected in test environment
 		return
 	}
 
 	t.Logf("Successfully cloned repository to %s via CLI", clonePath)
 }
-
-// ===== CLI Release Commands =====
-
-func TestCLIReleaseList(t *testing.T) {
-	env := NewTestEnv(t)
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"release", "list",
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("release list failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	t.Logf("Successfully listed releases via CLI")
-}
-
-func TestCLIReleaseCreateUploadDelete(t *testing.T) {
-	env := NewTestEnv(t)
-
-	tag := fmt.Sprintf("fj-test-%d", time.Now().UnixNano())
-	title := "FJ CLI Release Test"
-	notes := "Release created by functional tests"
-
-	tmpDir := t.TempDir()
-	assetPath := fmt.Sprintf("%s/asset.txt", tmpDir)
-	if err := os.WriteFile(assetPath, []byte("fj release asset"), 0600); err != nil {
-		t.Fatalf("failed to create asset file: %v", err)
-	}
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"release", "create", tag,
-		"-t", title,
-		"-n", notes,
-		assetPath,
-	)
-	if result.ExitCode != 0 {
-		t.Fatalf("release create failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	release, _, err := env.Client.GetReleaseByTag(env.Owner, env.RepoName, tag)
-	if err != nil {
-		t.Fatalf("failed to fetch created release: %v", err)
-	}
-	if release.Title != title {
-		t.Fatalf("expected release title %q, got %q", title, release.Title)
-	}
-
-	attachments, _, err := env.Client.ListReleaseAttachments(env.Owner, env.RepoName, release.ID, gitea.ListReleaseAttachmentsOptions{})
-	if err != nil {
-		t.Fatalf("failed to list release assets: %v", err)
-	}
-	found := false
-	for _, attachment := range attachments {
-		if attachment.Name == "asset.txt" {
-			found = true
-			break
-		}
-	}
-	if !found {
-		t.Fatalf("uploaded asset not found in release")
-	}
-
-	deleteResult := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"release", "delete", tag,
-	)
-	if deleteResult.ExitCode != 0 {
-		t.Fatalf("release delete failed with exit code %d: %s", deleteResult.ExitCode, deleteResult.Stderr)
-	}
-
-	_, _, err = env.Client.GetReleaseByTag(env.Owner, env.RepoName, tag)
-	if err == nil {
-		t.Fatalf("expected release %s to be deleted, but it still exists", tag)
-	}
-}
-
-func TestCLIReleaseView(t *testing.T) {
-	env := NewTestEnv(t)
-
-	// Create a release to view
-	tag := fmt.Sprintf("fj-view-test-%d", time.Now().UnixNano())
-
-	createResult := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"release", "create", tag,
-		"-t", "View Test Release",
-		"-n", "For release view test",
-	)
-	if createResult.ExitCode != 0 {
-		t.Fatalf("release create failed: %s", createResult.Stderr)
-	}
-
-	defer env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"release", "delete", tag,
-	)
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"release", "view", tag,
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("release view failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	if !strings.Contains(result.Stdout, "View Test Release") {
-		t.Fatalf("expected release title in output, got: %s", result.Stdout)
-	}
-
-	t.Logf("Successfully viewed release %s via CLI", tag)
-}
-
-// ===== CLI Label Commands =====
-
-func TestCLILabelCreateListEditDelete(t *testing.T) {
-	env := NewTestEnv(t)
-
-	rf := fmt.Sprintf("%s/%s", env.Owner, env.RepoName)
-
-	createResult := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", rf,
-		"label", "create", "test-label",
-		"--color", "00ff00",
-		"-d", "Test label for functional tests",
-	)
-
-	if createResult.ExitCode != 0 {
-		t.Fatalf("label create failed with exit code %d: %s", createResult.ExitCode, createResult.Stderr)
-	}
-
-	listResult := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", rf,
-		"label", "list",
-	)
-
-	if listResult.ExitCode != 0 {
-		t.Fatalf("label list failed with exit code %d: %s", listResult.ExitCode, listResult.Stderr)
-	}
-
-	if !strings.Contains(listResult.Stdout, "test-label") {
-		t.Fatalf("label list output does not contain 'test-label': %s", listResult.Stdout)
-	}
-
-	editResult := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", rf,
-		"label", "edit", "test-label",
-		"--name", "test-label-renamed",
-	)
-
-	if editResult.ExitCode != 0 {
-		t.Fatalf("label edit failed with exit code %d: %s", editResult.ExitCode, editResult.Stderr)
-	}
-
-	deleteResult := env.runCLIWithStdin("y\n",
-		"--hostname", env.Hostname,
-		"-R", rf,
-		"label", "delete", "test-label-renamed",
-	)
-
-	if deleteResult.ExitCode != 0 {
-		t.Fatalf("label delete failed with exit code %d: %s", deleteResult.ExitCode, deleteResult.Stderr)
-	}
-
-	t.Logf("Successfully created, listed, edited, and deleted label via CLI")
-}
-
-// ===== CLI Milestone Commands =====
-
-func TestCLIMilestoneCreateListViewEditDelete(t *testing.T) {
-	env := NewTestEnv(t)
-
-	rf := fmt.Sprintf("%s/%s", env.Owner, env.RepoName)
-
-	createResult := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", rf,
-		"milestone", "create", "Test Milestone",
-		"-d", "For testing",
-	)
-
-	if createResult.ExitCode != 0 {
-		t.Fatalf("milestone create failed with exit code %d: %s", createResult.ExitCode, createResult.Stderr)
-	}
-
-	listResult := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", rf,
-		"milestone", "list",
-	)
-
-	if listResult.ExitCode != 0 {
-		t.Fatalf("milestone list failed with exit code %d: %s", listResult.ExitCode, listResult.Stderr)
-	}
-
-	if !strings.Contains(listResult.Stdout, "Test Milestone") {
-		t.Fatalf("milestone list output does not contain 'Test Milestone': %s", listResult.Stdout)
-	}
-
-	viewResult := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", rf,
-		"milestone", "view", "Test Milestone",
-	)
-
-	if viewResult.ExitCode != 0 {
-		t.Fatalf("milestone view failed with exit code %d: %s", viewResult.ExitCode, viewResult.Stderr)
-	}
-
-	editResult := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", rf,
-		"milestone", "edit", "Test Milestone",
-		"--title", "Updated Milestone",
-	)
-
-	if editResult.ExitCode != 0 {
-		t.Fatalf("milestone edit failed with exit code %d: %s", editResult.ExitCode, editResult.Stderr)
-	}
-
-	deleteResult := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", rf,
-		"milestone", "delete", "Updated Milestone",
-	)
-
-	if deleteResult.ExitCode != 0 {
-		t.Fatalf("milestone delete failed with exit code %d: %s", deleteResult.ExitCode, deleteResult.Stderr)
-	}
-
-	t.Logf("Successfully created, listed, viewed, edited, and deleted milestone via CLI")
-}
-
-// ===== CLI Wiki Commands =====
-
-func TestCLIWikiCreateListViewEditDelete(t *testing.T) {
-	env := NewTestEnv(t)
-
-	rf := fmt.Sprintf("%s/%s", env.Owner, env.RepoName)
-
-	createResult := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", rf,
-		"wiki", "create", "Test Page",
-		"-b", "# Test\nContent",
-	)
-
-	if createResult.ExitCode != 0 {
-		t.Fatalf("wiki create failed with exit code %d: %s", createResult.ExitCode, createResult.Stderr)
-	}
-
-	defer func() {
-		env.RunCLI(
-			"--hostname", env.Hostname,
-			"-R", rf,
-			"wiki", "delete", "Test Page",
-		)
-	}()
-
-	listResult := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", rf,
-		"wiki", "list",
-	)
-
-	if listResult.ExitCode != 0 {
-		t.Fatalf("wiki list failed with exit code %d: %s", listResult.ExitCode, listResult.Stderr)
-	}
-
-	if !strings.Contains(listResult.Stdout, "Test Page") {
-		t.Fatalf("wiki list output does not contain 'Test Page': %s", listResult.Stdout)
-	}
-
-	viewResult := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", rf,
-		"wiki", "view", "Test Page",
-	)
-
-	if viewResult.ExitCode != 0 {
-		t.Fatalf("wiki view failed with exit code %d: %s", viewResult.ExitCode, viewResult.Stderr)
-	}
-
-	if !strings.Contains(viewResult.Stdout, "Content") {
-		t.Fatalf("wiki view output does not contain 'Content': %s", viewResult.Stdout)
-	}
-
-	editResult := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", rf,
-		"wiki", "edit", "Test Page",
-		"-b", "Updated content",
-	)
-
-	if editResult.ExitCode != 0 {
-		t.Fatalf("wiki edit failed with exit code %d: %s", editResult.ExitCode, editResult.Stderr)
-	}
-
-	deleteResult := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", rf,
-		"wiki", "delete", "Test Page",
-	)
-
-	if deleteResult.ExitCode != 0 {
-		t.Fatalf("wiki delete failed with exit code %d: %s", deleteResult.ExitCode, deleteResult.Stderr)
-	}
-
-	t.Logf("Successfully created, listed, viewed, edited, and deleted wiki page via CLI")
-}
-
-// ===== CLI Actions Commands =====
-
-func TestCLIActionsRunList(t *testing.T) {
-	env := NewTestEnv(t)
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"actions", "run", "list",
-	)
-
-	// Actions might not be enabled, so we accept both success and failure
-	if result.ExitCode != 0 {
-		if bytes.Contains([]byte(result.Stderr), []byte("404")) {
-			t.Logf("Note: Actions not available on this instance")
-			return
-		}
-		t.Fatalf("actions run list failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	t.Logf("Successfully listed workflow runs via CLI")
-}
-
-// ===== CLI API Command =====
-
-func TestCLIAPIGet(t *testing.T) {
-	env := NewTestEnv(t)
-
-	endpoint := fmt.Sprintf("/repos/%s/%s", env.Owner, env.RepoName)
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"api", endpoint,
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("api GET failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	var data map[string]interface{}
-	if err := json.Unmarshal([]byte(result.Stdout), &data); err != nil {
-		t.Fatalf("failed to parse JSON output: %v", err)
-	}
-
-	name, ok := data["name"].(string)
-	if !ok || name != env.RepoName {
-		t.Fatalf("expected repo name %q in JSON output, got %v", env.RepoName, data["name"])
-	}
-
-	t.Logf("Successfully retrieved repo info via fj api GET")
-}
-
-func TestCLIAPIPostAndDelete(t *testing.T) {
-	env := NewTestEnv(t)
-
-	endpoint := fmt.Sprintf("/repos/%s/%s/issues", env.Owner, env.RepoName)
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"api", endpoint,
-		"-X", "POST",
-		"-f", "title=[FJ E2E Test] API Post Test",
-		"-f", "body=Created via fj api command",
-	)
-
-	if result.ExitCode != 0 {
-		t.Fatalf("api POST failed with exit code %d: %s", result.ExitCode, result.Stderr)
-	}
-
-	var issueData map[string]interface{}
-	if err := json.Unmarshal([]byte(result.Stdout), &issueData); err != nil {
-		t.Fatalf("failed to parse JSON response: %v", err)
-	}
-
-	issueNumber, ok := issueData["number"].(float64)
-	if !ok || issueNumber == 0 {
-		t.Fatalf("expected issue number in response, got %v", issueData["number"])
-	}
-
-	issueNum := int64(issueNumber)
-	defer env.CleanupIssue(issueNum)
-
-	t.Logf("Successfully created issue #%d via fj api POST", issueNum)
-}
-
-// ===== Structured Error Output =====
-
-func TestCLIJSONErrors(t *testing.T) {
-	env := NewTestEnv(t)
-
-	result := env.RunCLI(
-		"--hostname", env.Hostname,
-		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
-		"issue", "view", "999999",
-		"--json-errors",
-	)
-
-	if result.ExitCode == 0 {
-		t.Fatalf("expected non-zero exit code for non-existent issue, got 0")
-	}
-
-	// Stderr may contain cobra usage text mixed with JSON error output.
-	stderr := result.Stderr
-	jsonStart := strings.Index(stderr, "{")
-	jsonEnd := strings.LastIndex(stderr, "}")
-	if jsonStart < 0 || jsonEnd < 0 || jsonEnd <= jsonStart {
-		t.Fatalf("expected JSON error output in stderr, but no JSON found.\nStderr: %s", stderr)
-	}
-	jsonStr := stderr[jsonStart : jsonEnd+1]
-
-	var errData map[string]interface{}
-	if err := json.Unmarshal([]byte(jsonStr), &errData); err != nil {
-		t.Fatalf("expected JSON error output in stderr, got parse error: %v\nJSON: %s\nFull stderr: %s", err, jsonStr, stderr)
-	}
-
-	if _, hasCode := errData["code"]; !hasCode {
-		if _, hasMsg := errData["message"]; !hasMsg {
-			if _, hasErr := errData["error"]; !hasErr {
-				t.Fatalf("JSON error output missing expected fields (code/message/error): %v", errData)
-			}
-		}
-	}
-
-	t.Logf("Successfully verified --json-errors flag produces structured JSON error output")
-}