diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml
index ca2b95d..67d1021 100644
--- a/.gitea/workflows/ci.yml
+++ b/.gitea/workflows/ci.yml
@@ -15,7 +15,7 @@ jobs:
       - name: Set up Go
         uses: https://github.com/actions/setup-go@v5
         with:
-          go-version: '1.21'
+          go-version: '1.24'
           cache: true
 
       - name: Install golangci-lint
@@ -34,7 +34,7 @@ jobs:
       - name: Set up Go
         uses: https://github.com/actions/setup-go@v5
         with:
-          go-version: '1.21'
+          go-version: '1.24'
           cache: true
 
       - name: Build application
@@ -49,7 +49,7 @@ jobs:
       - name: Set up Go
         uses: https://github.com/actions/setup-go@v5
         with:
-          go-version: '1.21'
+          go-version: '1.24'
           cache: true
 
       - name: Run unit tests
@@ -66,13 +66,13 @@ jobs:
       - name: Set up Go
         uses: https://github.com/actions/setup-go@v5
         with:
-          go-version: '1.21'
+          go-version: '1.24'
           cache: true
 
       - 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
index ef53290..b1d76a4 100644
--- a/.gitea/workflows/nightly.yml
+++ b/.gitea/workflows/nightly.yml
@@ -18,13 +18,13 @@ jobs:
       - name: Set up Go
         uses: https://github.com/actions/setup-go@v5
         with:
-          go-version: '1.21'
+          go-version: '1.24'
           cache: true
 
       - 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/release.yml b/.gitea/workflows/release.yml
new file mode 100644
index 0000000..b6b24b6
--- /dev/null
+++ b/.gitea/workflows/release.yml
@@ -0,0 +1,36 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  goreleaser:
+    runs-on: codeberg-small
+    steps:
+      - name: Checkout code
+        uses: https://github.com/actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Fetch tags
+        run: git fetch --force --tags
+
+      - name: Set up Go
+        uses: https://github.com/actions/setup-go@v5
+        with:
+          go-version: '1.24'
+          cache: true
+
+      - name: Run GoReleaser
+        uses: https://github.com/goreleaser/goreleaser-action@v6
+        with:
+          distribution: goreleaser
+          version: "~> v2"
+          args: release --clean
+        env:
+          # Forgejo Actions injects GITEA_TOKEN for the workflow by default;
+          # override with RELEASE_TOKEN secret if a longer-lived token is needed.
+          GITEA_TOKEN: ${{ secrets.RELEASE_TOKEN || secrets.GITEA_TOKEN }}
+          GORELEASER_FORCE_TOKEN: gitea
diff --git a/.gitignore b/.gitignore
index 58e31fb..de67f36 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,12 +1,15 @@
 # Binaries
-fj
-bin/
+fgj
 *.exe
 *.exe~
 *.dll
 *.so
 *.dylib
 
+# Goreleaser output
+dist/
+bin/
+
 # Test binary
 *.test
 
diff --git a/.goreleaser.yaml b/.goreleaser.yaml
new file mode 100644
index 0000000..367e6ab
--- /dev/null
+++ b/.goreleaser.yaml
@@ -0,0 +1,91 @@
+# yaml-language-server: $schema=https://goreleaser.com/static/schema.json
+version: 2
+
+project_name: fgj
+
+before:
+  hooks:
+    - go mod tidy
+
+builds:
+  - id: fgj
+    binary: fgj
+    main: .
+    env:
+      - CGO_ENABLED=0
+    flags:
+      - -trimpath
+    ldflags:
+      - -s -w -X "forgejo.zerova.net/public/fgj-sid/cmd.version={{ .Version }}"
+    goos:
+      - linux
+      - darwin
+      - windows
+      - freebsd
+    goarch:
+      - amd64
+      - arm64
+      - arm
+    goarm:
+      - "6"
+      - "7"
+    ignore:
+      - goos: darwin
+        goarch: arm
+      - goos: windows
+        goarch: arm
+      - goos: freebsd
+        goarch: arm
+
+archives:
+  - id: default
+    name_template: >-
+      {{ .ProjectName }}-
+      {{- .Version }}-
+      {{- .Os }}-
+      {{- if eq .Arch "amd64" }}x86_64
+      {{- else if eq .Arch "386" }}i386
+      {{- else }}{{ .Arch }}{{ end }}
+      {{- if .Arm }}v{{ .Arm }}{{ end }}
+    formats: [tar.gz]
+    format_overrides:
+      - goos: windows
+        formats: [zip]
+    files:
+      - README.md
+      - LICENSE
+      - CHANGELOG.md
+
+checksum:
+  name_template: "checksums.txt"
+  algorithm: sha256
+
+snapshot:
+  version_template: "{{ incpatch .Version }}-next"
+
+changelog:
+  sort: asc
+  use: git
+  filters:
+    exclude:
+      - "^docs:"
+      - "^test:"
+      - "^chore:"
+      - "^ci:"
+      - "Merge pull request"
+      - "Merge branch"
+
+gitea_urls:
+  api: https://forgejo.zerova.net/api/v1
+  download: https://forgejo.zerova.net
+
+release:
+  draft: false
+  prerelease: auto
+  mode: replace
+  header: |
+    ## fgj {{ .Tag }}
+
+    Install with `go install forgejo.zerova.net/public/fgj-sid@{{ .Tag }}` or download a prebuilt binary below.
+  footer: |
+    **Full Changelog**: https://forgejo.zerova.net/public/fgj-sid/compare/{{ .PreviousTag }}...{{ .Tag }}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 170c5ec..f0ef142 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,151 +5,180 @@ 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
+## [Unreleased] — 0.4.0
 
-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.
+### Added — Repository Management
 
-### BREAKING
+- `fgj branch {list,rename,delete}` — list branches with protection
+  status, rename branches, delete (protected branches are refused).
+- `fgj branch {protect,unprotect}` — create, replace, or remove branch
+  protection rules with `--require-approvals`,
+  `--dismiss-stale-approvals`, `--require-signed-commits`,
+  `--block-on-rejected-reviews`, `--block-on-outdated-branch`,
+  `--push-whitelist`, `--merge-whitelist`, `--require-status-checks`.
+  `protect` is idempotent (create-or-edit).
+- `fgj repo delete` — type-to-confirm deletion; `--yes` for scripts.
+- `fgj repo search` — search repositories on the current host by
+  query, topic, or description; filter by `--type`, `--owner`,
+  `--private`, `--archived`.
+- `fgj repo migrate` — import from GitHub, GitLab, Gitea, Gogs, or
+  a plain Git remote; supports mirror mode and selective import of
+  wiki/labels/milestones/issues/PRs/releases/LFS.
+- `fgj repo create-from-template` — scaffold a repo from a template,
+  with fine-grained control over what to copy (content, topics,
+  labels, webhooks, git hooks, avatar).
 
-- `--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 — Pull Requests
 
-### Added
+- `fgj pr clean <n>` — delete the local branch created by
+  `fgj pr checkout`. Refuses if the PR is open (use `--force`) or
+  if the branch is currently checked out.
+- `fgj pr approve <n>` / `fgj pr reject <n>` — shortcuts over
+  `pr review`; `reject` requires a body.
+- `fgj pr review-comments <n>` — list inline review comments across
+  every review on a PR.
+- `fgj pr resolve <comment-id>` / `fgj pr unresolve <comment-id>` —
+  mark review threads (un)resolved. Requires Forgejo 8.x+ /
+  Gitea 1.22+ server-side.
 
-- `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.
+### Added — Notifications & Organizations
+
+- `fgj notification list [--all]` / `fgj notification read <id>` —
+  list unread (default) or all notifications; mark individual
+  threads read.
+- `fgj notification {unread,pin,unpin}` — flip thread state
+  (complements `read`). Uses the Gitea `NotifyStatus` enum.
+- `fgj org {list,create,delete}` — list your orgs, create with
+  visibility/description, delete with confirmation.
+- `fgj webhook {list,create,update,delete}` — full CRUD on repo
+  webhooks: gitea/slack/discord/etc. hook types, event selection,
+  content type, secret, branch filter, auth header.
+
+### Added — Releases, Actions, Milestones, Time
+
+- `fgj release asset {list,create,delete}` — granular release
+  attachment management. `delete` accepts numeric IDs or filenames.
+- `fgj actions run delete` — delete a completed workflow run. Refuses
+  non-terminal runs unless `--force`; suggests `actions run cancel`
+  for those.
+- `fgj milestone issues {add,remove}` — associate or disassociate
+  issues with a milestone. Milestone accepted as title or id.
+- `fgj time {list,add,delete,reset}` — tracked-time management. Accepts
+  Go duration strings (`30m`, `1h30m`). `list` with no arg shows the
+  authenticated user's times across all repos.
+
+### Added — Misc
+
+- `fgj open [number] [--url]` — launch the repo / issue / PR page in
+  the default browser; auto-detects issue-vs-PR; prints URL on
+  non-TTY stdout or with `--url`.
+- `fgj whoami` — show the authenticated user and host.
+- `fgj admin user list` — admin-gated user enumeration.
+- `fgj logins {list,default}` — complement to `fgj auth`. `list` shows
+  all configured hosts in a table, highlighting the default. `default`
+  gets/sets which hostname wins when no other signal is present.
+- `pr list` / `issue list` gain `--since` and `--before` flags
+  accepting `YYYY-MM-DD`, RFC 3339, `YYYY-MM-DD HH:MM:SS`, or relative
+  deltas (`7d`, `24h`, `2w`, `1m`). Server-side filter for issues,
+  client-side for PRs (SDK lacks a PR-side filter).
+- `fgj label update` added as an alias for `fgj label edit`.
+- `fgj repo {archive,unarchive}` — toggle a repository's archived state
+  via `EditRepo`. Archiving prompts for confirmation (requires `--yes`
+  in non-TTY environments); unarchiving is reversible and skips the
+  prompt.
+- `fgj completion install [shell]` — idempotently writes the
+  completion script to the shell-standard location (XDG for bash,
+  `~/.zsh/completions/_fgj` for zsh, `~/.config/fish/completions/fgj.fish`
+  for fish; brew prefix on macOS when present). Supports `--dry-run`
+  and `--system` (bash only, prints the required sudo command).
 
 ### 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.
+- `fgj actions secret create` stdin handling reworked. Adds `--body`
+  (inline) and `--body-file` (path or `-` for stdin) flags; interactive
+  prompts now use hidden input via `term.ReadPassword`; piped stdin is
+  read whole (prior `fmt.Scanln` broke on spaces/newlines and echoed
+  the typed value). Empty values are rejected.
+- `HostConfig` gains an optional `default: true` field. When no other
+  signal selects a host (flag, `FGJ_HOST`, git remote, `match_dirs`),
+  the host marked default wins before the `codeberg.org` fallback.
+  Multiple `default: true` entries are tolerated with a stderr
+  warning; alphabetical-first wins.
+- Gitea SDK bumped `v0.22.1` → `v0.23.2` (last release compatible with
+  Go 1.24; `v0.24+` requires Go 1.26).
+
+### Development
+
+- Switched to standard semver tags (`v0.3.1`, `v0.4.0`, …); retired
+  letter-suffix scheme (`v0.3.0a`…`v0.3.0f`) which Go's module resolver
+  ignored, leaving `go install @latest` pointing at the pre-migration
+  `v0.3.0` tag.
+- Version string is now injected at build time via `-ldflags`; the
+  hardcoded constant in `cmd/root.go` has been replaced with a
+  `var version = "dev"` fallback. `make build` derives the version from
+  `git describe --tags --always --dirty`.
+- Added `.goreleaser.yaml` for multi-platform release builds
+  (linux/darwin/windows/freebsd × amd64/arm64/arm) with SHA256
+  checksums and auto-generated release notes.
+- Added `.gitea/workflows/release.yml` that publishes release artifacts
+  to the Forgejo release page on tag push.
+- Aligned CI Go version (`1.24`) with `go.mod`; previously CI ran on
+  `1.21` while `go.mod` required `1.24`.
+
+## [0.3.1] - 2026-04-19
 
 ### 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`).
+- `go install forgejo.zerova.net/public/fgj-sid@latest` now resolves
+  correctly. Previous releases used letter-suffix tags (`v0.3.0a`–`f`)
+  which are not valid Go module versions and were ignored by the
+  module resolver, leaving `@latest` pinned to `v0.3.0` — a commit
+  that predates the module-path migration from `codeberg.org/romaintb/fgj`.
 
 ## [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
+- `fgj label list` - List repository labels
+- `fgj label create` - Create a label with color and description
+- `fgj label edit` - Edit label name, color, or description
+- `fgj 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
+- `fgj milestone list` - List milestones with state filtering
+- `fgj milestone view` - View milestone details
+- `fgj milestone create` - Create a milestone with description and due date
+- `fgj milestone edit` - Edit milestone title, description, due date, or state
+- `fgj 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
+- `fgj wiki list` - List wiki pages
+- `fgj wiki view` - View wiki page content
+- `fgj wiki create` - Create a wiki page from flag or file
+- `fgj wiki edit` - Edit a wiki page
+- `fgj 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
+- `fgj issue edit --add-dependency <number>` - Add issue dependency
+- `fgj 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)
+- `fgj 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
+- `fgj 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
+- `fgj 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`)
@@ -159,14 +188,14 @@ this release ships fixes for all 13.
   - Response header display (`--include`/`-i`)
 
 #### Pull Request Management
-- `fj pr diff <number>` - View the diff for a pull request
+- `fgj 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
+- `fgj 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
+- `fgj 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`)
@@ -182,30 +211,30 @@ this release ships fixes for all 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
+- `fgj actions run watch <run-id>` - Poll a run until completion
+- `fgj actions run rerun <run-id>` - Trigger a rerun of a workflow run
+- `fgj actions run cancel <run-id>` - Cancel an in-progress workflow run
+- `fgj actions workflow enable <workflow>` - Enable a workflow
+- `fgj 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`
+- `fgj 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
+- `fgj issue create -l <label>` - Assign labels when creating an issue
+- `fgj issue edit --add-label` / `--remove-label` - Add or remove labels on existing issues
+- `fgj issue close -c <comment>` - Close an issue with an optional comment
 
 #### Workflow Management
-- `fj actions workflow list/view/run` - List, view, and trigger workflows
+- `fgj 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
+- `fgj auth token` - Print the stored token for the current host
+- `fgj 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
+- `fgj completion [bash|zsh|fish|powershell]` - Generate shell completion scripts
+- `fgj 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
@@ -218,17 +247,17 @@ this release ships fixes for all 13.
 ### 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)
+- `fgj release list` - List releases for a repository
+- `fgj release view` - View details of a specific release (supports "latest" keyword)
+- `fgj release create` - Create new releases with optional asset uploads
+- `fgj release upload` - Upload assets to existing releases with optional clobber support
+- `fgj release delete` - Delete releases (preserves Git tags)
 
 #### Issue Management
-- `fj issue edit` - Edit existing issues with support for updating title, body, and labels
+- `fgj 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
+- `fgj pr create --assignee` - Assign users when creating pull requests
 
 #### Repository Detection
 - Automatic hostname detection from git remote URLs
@@ -249,48 +278,48 @@ this release ships fixes for all 13.
 ### 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 +333,9 @@ 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.3.0c]: https://forgejo.zerova.net/public/fgj-sid/releases/tag/v0.3.0c
+[0.3.0b]: https://forgejo.zerova.net/public/fgj-sid/releases/tag/v0.3.0b
+[0.3.0a]: https://forgejo.zerova.net/public/fgj-sid/releases/tag/v0.3.0a
+[0.3.0]: https://codeberg.org/romaintb/fgj/releases/tag/v0.3.0
+[0.2.0]: https://codeberg.org/romaintb/fgj/releases/tag/v0.2.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..bb4657a 100644
--- a/Makefile
+++ b/Makefile
@@ -1,20 +1,26 @@
-.PHONY: help build run test clean lint lint-fix install
+.PHONY: help build run test clean lint lint-fix install release-snapshot release-check
+
+# Version derived from git tags; falls back to short SHA; appends -dirty if tree is modified.
+VERSION ?= $(shell git describe --tags --always --dirty 2>/dev/null || echo dev)
+LDFLAGS := -X 'forgejo.zerova.net/public/fgj-sid/cmd.version=$(VERSION)'
 
 help:
 	@echo "Available commands:"
-	@echo "  make build      - Build the application"
+	@echo "  make build      - Build the application (version: $(VERSION))"
 	@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"
 	@echo "  make lint-fix   - Run golangci-lint with auto-fix"
 	@echo "  make clean      - Clean build artifacts"
+	@echo "  make release-snapshot - Build snapshot release artifacts via goreleaser"
+	@echo "  make release-check    - Validate .goreleaser.yaml"
 
 build:
-	go build -o bin/fj .
+	go build -ldflags "$(LDFLAGS)" -o bin/fgj .
 
 install: build
-	install -Dm755 bin/fj /usr/bin/fj
+	install -Dm755 bin/fgj /usr/bin/fgj
 
 run:
 	go run .
@@ -29,5 +35,11 @@ lint-fix:
 	golangci-lint run --fix ./...
 
 clean:
-	rm -rf bin/
+	rm -rf bin/ dist/
 	go clean
+
+release-snapshot:
+	goreleaser release --snapshot --clean --skip=publish
+
+release-check:
+	goreleaser check
diff --git a/README.md b/README.md
index da5bac5..7391168 100644
--- a/README.md
+++ b/README.md
@@ -1,29 +1,34 @@
-# fj - Forgejo/Gitea CLI Tool
+# fgj - Forgejo/Gitea CLI Tool
 
 [![Go Version](https://img.shields.io/badge/Go-1.23+-00ADD8?style=flat-square&logo=go)](https://golang.org)
 [![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.
+`fgj` 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).
+> Forked from [codeberg.org/romaintb/fgj](https://codeberg.org/romaintb/fgj) and hosted at [forgejo.zerova.net/public/fgj-sid](https://forgejo.zerova.net/public/fgj-sid).
 
 ## 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
+- Pull requests — list, view, create, merge, close, reopen, edit, checkout, clean, diff, comment, review, approve, reject, checks, review-comments, resolve/unresolve
+- Issues — create, list, view, comment, close, reopen, edit, labels, dependencies
+- Repositories — view, list, create, edit, clone, fork, rename, delete, search, migrate, create-from-template
+- Branches — list, rename, delete
+- Labels / milestones / wiki — full CRUD
+- Organizations — list, create, delete
+- Webhooks — list, create, update, delete
+- Notifications — list (unread or all), mark read
+- Forgejo Actions — workflow runs, watch/rerun/cancel, workflows enable/disable, secrets, variables
+- Releases — create, upload, delete
+- Admin — `admin user list` (admin-token only)
+- `fgj open` — launch a repo / issue / PR in the browser
+- `fgj whoami` — show the authenticated user on the current host
+- Raw API access (`fgj api`) for arbitrary REST calls
 - Shell completions (bash, zsh, fish, PowerShell) and man pages
-- JSON output (`--json`) for all list/view commands
+- JSON output (`--json`, `--json-fields`, `--jq`) for all list/view commands
 - Structured JSON error output (`--json-errors`) for machine consumption
 - Automatic repository and hostname detection from git context
+- Directory-scoped host defaults (`match_dirs`)
 - Secure authentication with personal access tokens
 - XDG Base Directory compliant config location
 - AI coding agent friendly
@@ -33,22 +38,22 @@
 ### macOS (Homebrew)
 
 ```bash
-brew tap public/sid git@forgejo.zerova.net:public/homebrew-sid.git
-brew install fj
+brew tap sid/fgj-sid https://forgejo.zerova.net/sid/homebrew-fgj-sid.git
+brew install fgj
 ```
 
 ### Using Go Install
 
 ```bash
-go install forgejo.zerova.net/public/fj@latest
+go install forgejo.zerova.net/public/fgj-sid@latest
 ```
 
 ### From Source
 
 ```bash
-git clone https://forgejo.zerova.net/public/fj.git
-cd fj
-go build -o fj .
+git clone https://forgejo.zerova.net/public/fgj-sid.git
+cd fgj-sid
+go build -o fgj .
 ```
 
 ## Quick Start
@@ -58,7 +63,7 @@ go build -o fj .
 First, authenticate with your Forgejo or Gitea instance:
 
 ```bash
-fj auth login
+fgj auth login
 ```
 
 You'll be prompted for:
@@ -74,34 +79,34 @@ To create a personal access token:
 ### 2. Check Authentication Status
 
 ```bash
-fj auth status
+fgj auth status
 ```
 
 ### Auth Helpers
 
 ```bash
 # Print the stored token for the current host
-fj auth token
+fgj auth token
 
 # Remove authentication for a host
-fj auth logout
+fgj auth logout
 ```
 
 ## 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.
@@ -110,307 +115,307 @@ The tool reads `.git/config` to find the origin remote and extract both the owne
 
 ```bash
 # List pull requests (auto-detects repo and hostname from git)
-fj pr list
+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
+fgj pr merge 123 --merge-method squash
 
 # View PR diff
-fj pr diff 123
+fgj pr diff 123
 
 # View diff with color
-fj pr diff 123 --color always
+fgj pr diff 123 --color always
 
 # Show only changed file names
-fj pr diff 123 --name-only
+fgj pr diff 123 --name-only
 
 # Show diffstat summary
-fj pr diff 123 --stat
+fgj pr diff 123 --stat
 
 # Comment on a pull request
-fj pr comment 123 -b "Looks good, minor nit on line 42"
+fgj pr comment 123 -b "Looks good, minor nit on line 42"
 
 # Comment from a file
-fj pr comment 123 --body-file review-notes.md
+fgj pr comment 123 --body-file review-notes.md
 
 # Approve a pull request
-fj pr review 123 --approve -b "LGTM"
+fgj pr review 123 --approve -b "LGTM"
 
 # Request changes
-fj pr review 123 --request-changes -b "Please fix the error handling"
+fgj 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 review 123 --comment -b "Some observations"
 ```
 
 ### Issues
 
 ```bash
 # List issues (auto-detects repo and hostname from git)
-fj issue list
+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"
+fgj 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" -l bug -l enhancement
 
 # 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
+fgj issue close 456
 
 # Close an issue with a comment
-fj issue close 456 -c "Fixed in v2.0"
+fgj 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
+fgj issue edit 456 -t "New Title"
+fgj 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
+fgj issue edit 456 --add-dependency 123
+fgj issue edit 456 --remove-dependency 123
 ```
 
 ### Labels
 
 ```bash
 # List labels
-fj label list
+fgj label list
 
 # Create a label
-fj label create bug --color ff0000 -d "Something isn't working"
+fgj label create bug --color ff0000 -d "Something isn't working"
 
 # Edit a label
-fj label edit bug --name bugfix --color ee0000
+fgj label edit bug --name bugfix --color ee0000
 
 # Delete a label
-fj label delete bug
+fgj label delete bug
 ```
 
 ### Milestones
 
 ```bash
 # List milestones
-fj milestone list
-fj milestone list --state all
+fgj milestone list
+fgj milestone list --state all
 
 # View a milestone
-fj milestone view "v1.0"
+fgj milestone view "v1.0"
 
 # Create a milestone with due date
-fj milestone create "v2.0" -d "Next major release" --due 2026-06-01
+fgj 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
+fgj milestone edit "v2.0" --title "v2.0-rc1" --state closed
 
 # Delete a milestone
-fj milestone delete "v2.0"
+fgj milestone delete "v2.0"
 ```
 
 ### Wiki
 
 ```bash
 # List wiki pages
-fj wiki list
+fgj wiki list
 
 # View a wiki page
-fj wiki view "Home"
+fgj wiki view "Home"
 
 # Create a wiki page
-fj wiki create "Setup Guide" -b "# Setup\n\nFollow these steps..."
+fgj wiki create "Setup Guide" -b "# Setup\n\nFollow these steps..."
 
 # Create from file
-fj wiki create "API Docs" --body-file docs/api.md
+fgj wiki create "API Docs" --body-file docs/api.md
 
 # Edit a wiki page
-fj wiki edit "Home" -b "Updated content"
+fgj wiki edit "Home" -b "Updated content"
 
 # Delete a wiki page
-fj wiki delete "Old Page"
+fgj wiki delete "Old Page"
 ```
 
 ### Repositories
 
 ```bash
 # View repository details
-fj repo view owner/repo
+fgj repo view owner/repo
 
 # List your repositories
-fj repo list
+fgj 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 create my-repo
+fgj repo create my-repo -d "My project" --private --add-readme -g Go -l MIT
 
 # 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
+fgj 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
+fgj repo edit owner/repo --public
+fgj repo edit owner/repo --private
+fgj repo edit owner/repo -d "New description" --homepage https://example.com
+fgj repo edit --default-branch develop
+fgj 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
+fgj repo rename new-name
+fgj repo rename new-name -R owner/old-name
 ```
 
 ### Releases
 
 ```bash
 # List releases
-fj release list
+fgj release list
 
 # View a release (or use "latest")
-fj release view v1.2.3
+fgj 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
+fgj 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
+fgj release upload v1.2.3 ./dist/app.tar.gz --clobber
 
 # Delete a release (keeps the Git tag)
-fj release delete v1.2.3
+fgj release delete v1.2.3
 ```
 
 ### Forgejo Actions
 
 ```bash
 # List workflows
-fj actions workflow list
+fgj actions workflow list
 
 # View a workflow
-fj actions workflow view ci.yml
+fgj actions workflow view ci.yml
 
 # Run a workflow (trigger workflow_dispatch)
-fj actions workflow run deploy.yml
+fgj actions workflow run deploy.yml
 
 # Run a workflow with inputs
-fj actions workflow run deploy.yml -f environment=production -f version=1.2.3
+fgj 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
+fgj 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
+fgj actions workflow enable ci.yml
+fgj 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
+fgj actions run view 123 --job 456 --log
 
 # Watch a run until completion
-fj actions run watch 123
+fgj actions run watch 123
 
 # Rerun a workflow run
-fj actions run rerun 123
+fgj actions run rerun 123
 
 # Cancel a running workflow
-fj actions run cancel 123
+fgj actions run cancel 123
 
 # 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
+fgj actions variable delete MY_VAR
 ```
 
 ### Raw API Access
 
 ```bash
 # GET request (auto-detects owner/repo from git context)
-fj api /repos/{owner}/{repo}/pulls
+fgj api /repos/{owner}/{repo}/pulls
 
 # POST with fields
-fj api /repos/{owner}/{repo}/issues -X POST -f title="Bug report" -f body="Description"
+fgj 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
+fgj 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
+fgj 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 -
+echo '{"title":"test"}' | fgj api /repos/{owner}/{repo}/issues -X POST --input -
 
 # Include response headers
-fj api /repos/{owner}/{repo} -i
+fgj api /repos/{owner}/{repo} -i
 
 # Suppress output (useful for DELETE)
-fj api /repos/{owner}/{repo}/issues/123 -X DELETE --silent
+fgj 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
+fgj completion bash > /etc/bash_completion.d/fgj
+fgj completion zsh > "${fpath[1]}/_fgj"
+fgj completion fish > ~/.config/fish/completions/fgj.fish
 
 # Generate man pages to a directory
-fj manpages --dir ~/.local/share/man/man1
+fgj manpages --dir ~/.local/share/man/man1
 ```
 
 ## JSON Output
@@ -418,15 +423,15 @@ fj manpages --dir ~/.local/share/man/man1
 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
+fgj pr list --json
+fgj issue view 456 --json
+fgj release list --json
+fgj actions run list --json
+fgj 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
+fgj pr comment 123 -b "LGTM" --json
+fgj pr review 123 --approve -b "Ship it" --json
 ```
 
 ### Structured Error Output
@@ -435,16 +440,16 @@ For machine consumption (ideal for AI agents and scripts), use `--json-errors` t
 
 ```bash
 # Errors are written to stderr as JSON
-fj pr view 9999 --json-errors
+fgj 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 pr list --json --json-errors
 ```
 
 ## Configuration
 
-Configuration is stored in `~/.config/fj/config.yaml`:
+Configuration is stored in `~/.config/fgj/config.yaml`:
 
 ```yaml
 hosts:
@@ -466,9 +471,9 @@ hosts:
 
 ### 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.
+When you work with multiple Forgejo/Gitea instances, `fgj` 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.
+Each host entry supports a `match_dirs` list of directory paths. When `fgj` 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:
@@ -494,12 +499,12 @@ hosts:
 
 ### Environment Variables
 
-- `FJ_HOST`: Override the default instance (auto-detected from git remote if not set)
-- `FJ_TOKEN`: Provide authentication token
+- `FGJ_HOST`: Override the default instance (auto-detected from git remote if not set)
+- `FGJ_TOKEN`: Provide authentication token
 
 Hostname is resolved in this priority order:
 1. Command-specific flags (e.g., `--hostname`)
-2. `FJ_HOST` environment variable
+2. `FGJ_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`
@@ -509,15 +514,15 @@ Hostname is resolved in this priority order:
 - `--hostname`: Specify instance for a command (overrides auto-detection and environment variables)
 - `--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.
+When working in a git repository, `fgj` 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. Use `--json` and `--json-errors` for fully machine-readable I/O:
 
 ```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
@@ -527,29 +532,29 @@ EOF
 )" --json
 
 # Check PR status during development
-fj pr list -R owner/repo --state open --json
+fgj pr list -R owner/repo --state open --json
 
 # Review a PR diff, then approve
-fj pr diff 123
-fj pr review 123 --approve -b "LGTM" --json
+fgj pr diff 123
+fgj 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
+fgj 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
+fgj 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"
+fgj api /repos/{owner}/{repo}/topics --json-errors
+fgj 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
+fgj pr view 9999 --json --json-errors 2>errors.json
 ```
 
 ## Supported Instances
 
-`fj` works with any Forgejo or Gitea instance, including:
+`fgj` works with any Forgejo or Gitea instance, including:
 
 - Self-hosted Forgejo instances
 - Self-hosted Gitea instances
@@ -557,11 +562,11 @@ fj pr view 9999 --json --json-errors 2>errors.json
 
 ## Contributing
 
-Contributions are welcome! Please feel free to submit a Pull Request at [forgejo.zerova.net/public/fj](https://forgejo.zerova.net/public/fj).
+Contributions are welcome! Please feel free to submit a Pull Request at [forgejo.zerova.net/public/fgj-sid](https://forgejo.zerova.net/public/fgj-sid).
 
 ## 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:
+`fgj` 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
@@ -576,7 +581,7 @@ 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.
+Based on [fgj by romaintb](https://codeberg.org/romaintb/fgj). Enhanced with agentic dev features for AI-assisted workflows.
 
 ## License
 
diff --git a/cmd/actions.go b/cmd/actions.go
index 172831c..9f65af4 100644
--- a/cmd/actions.go
+++ b/cmd/actions.go
@@ -10,8 +10,8 @@ import (
 	"code.gitea.io/sdk/gitea"
 	"github.com/spf13/cobra"
 
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
 )
 
 // ActionRun represents a workflow run
@@ -87,224 +87,146 @@ 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
+var runListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List recent workflow runs",
+	Long:  "List recent workflow runs for a repository.",
+	Example: `  # List recent workflow runs
+  fgj actions run list
 
   # List runs with a custom limit
-  fj actions run list -L 50
+  fgj 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
+  fgj actions run list --json`,
+	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
+var runViewCmd = &cobra.Command{
+	Use:   "view <run-id>",
+	Short: "View a workflow run",
+	Long:  "View details about a specific workflow run.",
+	Example: `  # View a workflow run
+  fgj actions run view 123
 
   # View with job details
-  fj actions run view 123 -v
+  fgj actions run view 123 -v
 
   # View logs for a specific job
-  fj actions run view 123 --job 456 --log
+  fgj 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
+  fgj actions run view 123 --log-failed`,
+	Args: cobra.ExactArgs(1),
+	RunE: runRunView,
 }
 
-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
+var runWatchCmd = &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
+  fgj 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
+  fgj actions run watch 123 -i 10s`,
+	Args: cobra.ExactArgs(1),
+	RunE: runRunWatch,
 }
 
-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
+var runRerunCmd = &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
+  fgj actions run rerun 123`,
+	Args: cobra.ExactArgs(1),
+	RunE: runRunRerun,
 }
 
-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
+var runCancelCmd = &cobra.Command{
+	Use:   "cancel <run-id>",
+	Short: "Cancel a workflow run",
+	Long:  "Cancel a running workflow run.",
+	Example: `  # Cancel a running workflow
+  fgj actions run cancel 123`,
+	Args: cobra.ExactArgs(1),
+	RunE: runRunCancel,
 }
 
-// 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
+// Workflow commands
+var workflowCmd = &cobra.Command{
+	Use:   "workflow",
+	Short: "Manage workflows",
+	Long:  "List, view, and run workflows.",
 }
 
-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
+var workflowListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List workflows",
+	Long:  "List all workflows in a repository.",
+	Example: `  # List all workflows
+  fgj actions workflow list
 
   # List workflows as JSON
-  fj actions workflow list --json
+  fgj 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
+  fgj actions workflow list -R owner/repo`,
+	RunE: runWorkflowList,
 }
 
-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
+var workflowViewCmd = &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
+  fgj 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
+  fgj actions workflow view ci.yml --json`,
+	Args: cobra.ExactArgs(1),
+	RunE: runWorkflowView,
 }
 
-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
+var workflowRunCmd = &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
+  fgj 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
+  fgj actions workflow run deploy.yml -r staging -f environment=staging -f version=1.2.3`,
+	Args: cobra.ExactArgs(1),
+	RunE: runWorkflowRun,
 }
 
-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
+var workflowEnableCmd = &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
+  fgj actions workflow enable ci.yml`,
+	Args: cobra.ExactArgs(1),
+	RunE: runWorkflowEnable,
 }
 
-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 workflowDisableCmd = &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
+  fgj actions workflow disable ci.yml`,
+	Args: cobra.ExactArgs(1),
+	RunE: runWorkflowDisable,
 }
 
 // Secret commands
@@ -319,22 +241,36 @@ var actionsSecretListCmd = &cobra.Command{
 	Short: "List repository secrets",
 	Long:  "List all secrets for a repository.",
 	Example: `  # List all secrets
-  fj actions secret list
+  fgj actions secret list
 
   # List secrets for a specific repo
-  fj actions secret list -R owner/repo`,
+  fgj actions secret list -R owner/repo`,
 	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
+	Long: `Create or update a secret for Forgejo Actions.
 
-  # Create a secret for a specific repo
-  fj actions secret create API_KEY -R owner/repo`,
+The secret value is read from the first available source:
+  1. --body <value>
+  2. --body-file <path> (use "-" for stdin)
+  3. interactive prompt (hidden input) if stdin is a TTY
+  4. stdin (when piped)
+
+Trailing newlines are trimmed. Empty values are rejected.`,
+	Example: `  # Interactive (hidden prompt)
+  fgj actions secret create DEPLOY_TOKEN
+
+  # Pipe a value
+  op read op://vault/github/token | fgj actions secret create GH_TOKEN --body-file -
+
+  # Read from a file
+  fgj actions secret create TLS_KEY --body-file ./server.key
+
+  # Inline (visible in shell history — use sparingly)
+  fgj actions secret create DEBUG_FLAG --body "on"`,
 	Args: cobra.ExactArgs(1),
 	RunE: runActionsSecretCreate,
 }
@@ -344,7 +280,7 @@ var actionsSecretDeleteCmd = &cobra.Command{
 	Short: "Delete a repository secret",
 	Long:  "Delete a secret from Forgejo Actions.",
 	Example: `  # Delete a secret
-  fj actions secret delete DEPLOY_TOKEN`,
+  fgj actions secret delete DEPLOY_TOKEN`,
 	Args: cobra.ExactArgs(1),
 	RunE: runActionsSecretDelete,
 }
@@ -361,10 +297,10 @@ var actionsVariableListCmd = &cobra.Command{
 	Short: "List repository variables",
 	Long:  "List all variables for a repository.",
 	Example: `  # List all variables
-  fj actions variable list
+  fgj actions variable list
 
   # List variables for a specific repo
-  fj actions variable list -R owner/repo`,
+  fgj actions variable list -R owner/repo`,
 	RunE: runActionsVariableList,
 }
 
@@ -373,7 +309,7 @@ var actionsVariableGetCmd = &cobra.Command{
 	Short: "Get a repository variable",
 	Long:  "Get the value of a specific repository variable.",
 	Example: `  # Get a variable value
-  fj actions variable get ENVIRONMENT`,
+  fgj actions variable get ENVIRONMENT`,
 	Args: cobra.ExactArgs(1),
 	RunE: runActionsVariableGet,
 }
@@ -383,10 +319,10 @@ var actionsVariableCreateCmd = &cobra.Command{
 	Short: "Create a repository variable",
 	Long:  "Create a new variable for Forgejo Actions.",
 	Example: `  # Create a variable
-  fj actions variable create ENVIRONMENT production
+  fgj actions variable create ENVIRONMENT production
 
   # Create a variable for a specific repo
-  fj actions variable create NODE_VERSION 20 -R owner/repo`,
+  fgj actions variable create NODE_VERSION 20 -R owner/repo`,
 	Args: cobra.ExactArgs(2),
 	RunE: runActionsVariableCreate,
 }
@@ -396,7 +332,7 @@ var actionsVariableUpdateCmd = &cobra.Command{
 	Short: "Update a repository variable",
 	Long:  "Update an existing variable for Forgejo Actions.",
 	Example: `  # Update a variable
-  fj actions variable update ENVIRONMENT staging`,
+  fgj actions variable update ENVIRONMENT staging`,
 	Args: cobra.ExactArgs(2),
 	RunE: runActionsVariableUpdate,
 }
@@ -406,7 +342,7 @@ var actionsVariableDeleteCmd = &cobra.Command{
 	Short: "Delete a repository variable",
 	Long:  "Delete a variable from Forgejo Actions.",
 	Example: `  # Delete a variable
-  fj actions variable delete ENVIRONMENT`,
+  fgj actions variable delete ENVIRONMENT`,
 	Args: cobra.ExactArgs(1),
 	RunE: runActionsVariableDelete,
 }
@@ -414,10 +350,21 @@ var actionsVariableDeleteCmd = &cobra.Command{
 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)
+	runCmd.AddCommand(runWatchCmd)
+	runCmd.AddCommand(runRerunCmd)
+	runCmd.AddCommand(runCancelCmd)
+
+	// Add workflow commands (gh workflow compatible)
+	actionsCmd.AddCommand(workflowCmd)
+	workflowCmd.AddCommand(workflowListCmd)
+	workflowCmd.AddCommand(workflowViewCmd)
+	workflowCmd.AddCommand(workflowRunCmd)
+	workflowCmd.AddCommand(workflowEnableCmd)
+	workflowCmd.AddCommand(workflowDisableCmd)
 
 	// Add secret commands
 	actionsCmd.AddCommand(actionsSecretCmd)
@@ -433,9 +380,39 @@ 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")
+	addJSONFlags(runListCmd, "Output workflow runs as JSON")
+	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")
+	addJSONFlags(runViewCmd, "Output workflow run as JSON")
+	addRepoFlags(runWatchCmd)
+	runWatchCmd.Flags().DurationP("interval", "i", 5*time.Second, "Polling interval")
+	addRepoFlags(runRerunCmd)
+	addRepoFlags(runCancelCmd)
+
+	// Add flags for workflow commands
+	addRepoFlags(workflowListCmd)
+	workflowListCmd.Flags().IntP("limit", "L", 20, "Maximum number of workflows to list")
+	addJSONFlags(workflowListCmd, "Output workflows as JSON")
+	addRepoFlags(workflowViewCmd)
+	addJSONFlags(workflowViewCmd, "Output workflow as JSON")
+	addRepoFlags(workflowRunCmd)
+	addRepoFlags(workflowEnableCmd)
+	addRepoFlags(workflowDisableCmd)
+	workflowRunCmd.Flags().StringP("ref", "r", "", "Branch or tag name to run the workflow on (defaults to repository's default branch)")
+	workflowRunCmd.Flags().StringSliceP("field", "f", nil, "Add a string parameter in key=value format (can be used multiple times)")
+	workflowRunCmd.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)")
+
 	// Add flags for secret commands
 	addRepoFlags(actionsSecretListCmd)
 	addRepoFlags(actionsSecretCreateCmd)
+	actionsSecretCreateCmd.Flags().String("body", "", "Secret value (visible in shell history)")
+	actionsSecretCreateCmd.Flags().String("body-file", "", "Read secret value from file, or '-' for stdin")
 	addRepoFlags(actionsSecretDeleteCmd)
 
 	// Add flags for variable commands
@@ -1293,12 +1270,9 @@ func runActionsSecretCreate(cmd *cobra.Command, args []string) error {
 
 	secretName := args[0]
 
-	// Read secret value from stdin
-	fmt.Fprint(ios.ErrOut, "Enter secret value: ")
-	var secretValue string
-	_, err = fmt.Scanln(&secretValue)
+	secretValue, err := readSecretValue(cmd, secretName)
 	if err != nil {
-		return fmt.Errorf("failed to read secret value: %w", err)
+		return err
 	}
 
 	opt := gitea.CreateSecretOption{
@@ -1306,12 +1280,12 @@ func runActionsSecretCreate(cmd *cobra.Command, args []string) error {
 		Data: secretValue,
 	}
 
-	_, err = client.CreateRepoActionSecret(owner, name, opt)
-	if err != nil {
+	if _, err := client.CreateRepoActionSecret(owner, name, opt); err != nil {
 		return fmt.Errorf("failed to create secret: %w", err)
 	}
 
-	fmt.Fprintf(ios.Out, "Secret '%s' created successfully\n", secretName)
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Secret %q created\n", cs.SuccessIcon(), secretName)
 	return nil
 }
 
diff --git a/cmd/actions_run_delete.go b/cmd/actions_run_delete.go
new file mode 100644
index 0000000..75a27d1
--- /dev/null
+++ b/cmd/actions_run_delete.go
@@ -0,0 +1,99 @@
+package cmd
+
+import (
+	"fmt"
+	"net/http"
+	"strconv"
+
+	"github.com/spf13/cobra"
+
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+)
+
+var runDeleteCmd = &cobra.Command{
+	Use:     "delete <run-id>",
+	Aliases: []string{"rm"},
+	Short:   "Delete a workflow run",
+	Long: `Delete a completed workflow run.
+
+By default, the run is fetched first and deletion is refused if the run
+is still pending, running, or waiting. Use --force to override this and
+delete a non-terminal run. To stop an in-progress run, use
+'fgj actions run cancel' instead.`,
+	Example: `  # Delete a completed run (with confirmation)
+  fgj actions run delete 123
+
+  # Delete without confirmation
+  fgj actions run delete 123 -y
+
+  # Force delete a non-terminal run
+  fgj actions run delete 123 --force -y`,
+	Args: cobra.ExactArgs(1),
+	RunE: runRunDelete,
+}
+
+func init() {
+	runCmd.AddCommand(runDeleteCmd)
+	addRepoFlags(runDeleteCmd)
+	runDeleteCmd.Flags().BoolP("yes", "y", false, "Skip confirmation prompt")
+	runDeleteCmd.Flags().Bool("force", false, "Allow deleting a non-terminal (pending/running/waiting) run")
+}
+
+func runRunDelete(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)
+	}
+
+	skipConfirm, _ := cmd.Flags().GetBool("yes")
+	force, _ := cmd.Flags().GetBool("force")
+
+	// Fetch the run to check state and to display status in the confirmation prompt.
+	runEndpoint := fmt.Sprintf("/api/v1/repos/%s/%s/actions/runs/%d", owner, name, runID)
+	var run ActionRun
+	if err := client.GetJSON(runEndpoint, &run); err != nil {
+		return fmt.Errorf("failed to get run: %w", err)
+	}
+
+	if !isRunComplete(run.Status) && !force {
+		return fmt.Errorf("run %d is %s; refusing to delete a non-terminal run. Use 'fgj actions run cancel %d' to stop it, or pass --force to delete anyway",
+			runID, run.Status, runID)
+	}
+
+	if !skipConfirm && ios.IsStdinTTY() {
+		answer, err := promptLine(fmt.Sprintf("Delete run %d (%s) in %s/%s? [y/N]: ", runID, run.Status, owner, name))
+		if err != nil {
+			return err
+		}
+		if answer != "y" && answer != "Y" && answer != "yes" {
+			fmt.Fprintln(ios.ErrOut, "Cancelled.")
+			return nil
+		}
+	}
+
+	deleteEndpoint := fmt.Sprintf("/api/v1/repos/%s/%s/actions/runs/%d", owner, name, runID)
+	if _, err := client.DoJSON(http.MethodDelete, deleteEndpoint, nil, nil); err != nil {
+		return fmt.Errorf("failed to delete run %d: %w", runID, err)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Deleted run %d\n", cs.SuccessIcon(), runID)
+	return nil
+}
diff --git a/cmd/admin.go b/cmd/admin.go
new file mode 100644
index 0000000..cbc390e
--- /dev/null
+++ b/cmd/admin.go
@@ -0,0 +1,85 @@
+package cmd
+
+import (
+	"fmt"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/spf13/cobra"
+)
+
+var adminCmd = &cobra.Command{
+	Use:     "admin",
+	Aliases: []string{"a"},
+	Short:   "Operations requiring admin access",
+	Long:    "Administrative operations on the current host. These require an admin-scoped token.",
+}
+
+var adminUserCmd = &cobra.Command{
+	Use:     "user",
+	Aliases: []string{"users", "u"},
+	Short:   "Manage users on the host",
+	Long:    "Admin-scoped user management.",
+}
+
+var adminUserListCmd = &cobra.Command{
+	Use:     "list",
+	Aliases: []string{"ls"},
+	Short:   "List all users on the host",
+	Example: `  # List users
+  fgj admin user list
+
+  # Limit and output as JSON
+  fgj admin user list --limit 100 --json`,
+	RunE: runAdminUserList,
+}
+
+func init() {
+	rootCmd.AddCommand(adminCmd)
+	adminCmd.AddCommand(adminUserCmd)
+	adminUserCmd.AddCommand(adminUserListCmd)
+
+	adminUserListCmd.Flags().IntP("limit", "L", 50, "Maximum number of users to list")
+	addJSONFlags(adminUserListCmd, "Output as JSON")
+}
+
+func runAdminUserList(cmd *cobra.Command, args []string) error {
+	client, err := loadClient()
+	if err != nil {
+		return err
+	}
+
+	limit, _ := cmd.Flags().GetInt("limit")
+	if limit <= 0 {
+		limit = 50
+	}
+
+	users, _, err := client.AdminListUsers(gitea.AdminListUsersOptions{
+		ListOptions: gitea.ListOptions{PageSize: limit},
+	})
+	if err != nil {
+		return fmt.Errorf("failed to list users (admin token required): %w", err)
+	}
+
+	if wantJSON(cmd) {
+		return outputJSON(cmd, users)
+	}
+
+	if len(users) == 0 {
+		fmt.Fprintln(ios.Out, "No users found.")
+		return nil
+	}
+
+	tp := ios.NewTablePrinter()
+	tp.AddHeader("LOGIN", "FULL NAME", "EMAIL", "ADMIN", "ACTIVE")
+	for _, u := range users {
+		admin, active := "", "yes"
+		if u.IsAdmin {
+			admin = "yes"
+		}
+		if !u.IsActive {
+			active = "no"
+		}
+		tp.AddRow(u.UserName, u.FullName, u.Email, admin, active)
+	}
+	return tp.Render()
+}
diff --git a/cmd/aliases.go b/cmd/aliases.go
index 46f0a24..10447e7 100644
--- a/cmd/aliases.go
+++ b/cmd/aliases.go
@@ -1,16 +1,142 @@
 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).
+import (
+	"time"
+
+	"github.com/spf13/cobra"
+)
+
+// Top-level aliases for "actions run" and "actions workflow" commands,
+// matching gh CLI's command structure (e.g., "fgj run list" instead of "fgj actions run list").
 
 func init() {
-	rootCmd.AddCommand(newRunCmd(" (alias for 'actions run')"))
-	rootCmd.AddCommand(newWorkflowCmd(" (alias for 'actions workflow')"))
+	// --- run alias ---
+	runAliasCmd := &cobra.Command{
+		Use:   "run",
+		Short: "View and manage workflow runs (alias for 'actions run')",
+		Long:  "List, view, and manage workflow runs.\n\nThis is a top-level alias for 'actions run'.",
+	}
+
+	runAliasListCmd := &cobra.Command{
+		Use:   "list",
+		Short: "List recent workflow runs",
+		Long:  "List recent workflow runs for a repository.",
+		RunE:  runRunList,
+	}
+	addRepoFlags(runAliasListCmd)
+	runAliasListCmd.Flags().IntP("limit", "L", 20, "Maximum number of runs to list")
+	runAliasListCmd.Flags().Bool("json", false, "Output workflow runs as JSON")
+
+	runAliasViewCmd := &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,
+	}
+	addRepoFlags(runAliasViewCmd)
+	runAliasViewCmd.Flags().BoolP("verbose", "v", false, "Show job steps")
+	runAliasViewCmd.Flags().BoolP("log", "", false, "View full log for either a run or specific job")
+	runAliasViewCmd.Flags().StringP("job", "j", "", "View a specific job ID from a run")
+	runAliasViewCmd.Flags().BoolP("log-failed", "", false, "View the log for any failed steps in a run or specific job")
+	runAliasViewCmd.Flags().Bool("json", false, "Output workflow run as JSON")
+
+	runAliasWatchCmd := &cobra.Command{
+		Use:   "watch <run-id>",
+		Short: "Watch a workflow run",
+		Long:  "Poll a workflow run until it completes.",
+		Args:  cobra.ExactArgs(1),
+		RunE:  runRunWatch,
+	}
+	addRepoFlags(runAliasWatchCmd)
+	runAliasWatchCmd.Flags().DurationP("interval", "i", 5*time.Second, "Polling interval")
+
+	runAliasRerunCmd := &cobra.Command{
+		Use:   "rerun <run-id>",
+		Short: "Rerun a workflow run",
+		Long:  "Trigger a rerun for a specific workflow run.",
+		Args:  cobra.ExactArgs(1),
+		RunE:  runRunRerun,
+	}
+	addRepoFlags(runAliasRerunCmd)
+
+	runAliasCancelCmd := &cobra.Command{
+		Use:   "cancel <run-id>",
+		Short: "Cancel a workflow run",
+		Long:  "Cancel a running workflow run.",
+		Args:  cobra.ExactArgs(1),
+		RunE:  runRunCancel,
+	}
+	addRepoFlags(runAliasCancelCmd)
+
+	runAliasCmd.AddCommand(runAliasListCmd)
+	runAliasCmd.AddCommand(runAliasViewCmd)
+	runAliasCmd.AddCommand(runAliasWatchCmd)
+	runAliasCmd.AddCommand(runAliasRerunCmd)
+	runAliasCmd.AddCommand(runAliasCancelCmd)
+	rootCmd.AddCommand(runAliasCmd)
+
+	// --- workflow alias ---
+	workflowAliasCmd := &cobra.Command{
+		Use:   "workflow",
+		Short: "Manage workflows (alias for 'actions workflow')",
+		Long:  "List, view, and run workflows.\n\nThis is a top-level alias for 'actions workflow'.",
+	}
+
+	workflowAliasListCmd := &cobra.Command{
+		Use:   "list",
+		Short: "List workflows",
+		Long:  "List all workflows in a repository.",
+		RunE:  runWorkflowList,
+	}
+	addRepoFlags(workflowAliasListCmd)
+	workflowAliasListCmd.Flags().IntP("limit", "L", 20, "Maximum number of workflows to list")
+	workflowAliasListCmd.Flags().Bool("json", false, "Output workflows as JSON")
+
+	workflowAliasViewCmd := &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.",
+		Args:  cobra.ExactArgs(1),
+		RunE:  runWorkflowView,
+	}
+	addRepoFlags(workflowAliasViewCmd)
+	workflowAliasViewCmd.Flags().Bool("json", false, "Output workflow as JSON")
+
+	workflowAliasRunCmd := &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.",
+		Args:  cobra.ExactArgs(1),
+		RunE:  runWorkflowRun,
+	}
+	addRepoFlags(workflowAliasRunCmd)
+	workflowAliasRunCmd.Flags().StringP("ref", "r", "", "Branch or tag name to run the workflow on (defaults to repository's default branch)")
+	workflowAliasRunCmd.Flags().StringSliceP("field", "f", nil, "Add a string parameter in key=value format (can be used multiple times)")
+	workflowAliasRunCmd.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)")
+
+	workflowAliasEnableCmd := &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.",
+		Args:  cobra.ExactArgs(1),
+		RunE:  runWorkflowEnable,
+	}
+	addRepoFlags(workflowAliasEnableCmd)
+
+	workflowAliasDisableCmd := &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.",
+		Args:  cobra.ExactArgs(1),
+		RunE:  runWorkflowDisable,
+	}
+	addRepoFlags(workflowAliasDisableCmd)
+
+	workflowAliasCmd.AddCommand(workflowAliasListCmd)
+	workflowAliasCmd.AddCommand(workflowAliasViewCmd)
+	workflowAliasCmd.AddCommand(workflowAliasRunCmd)
+	workflowAliasCmd.AddCommand(workflowAliasEnableCmd)
+	workflowAliasCmd.AddCommand(workflowAliasDisableCmd)
+	rootCmd.AddCommand(workflowAliasCmd)
 }
diff --git a/cmd/api.go b/cmd/api.go
index 753ff49..f5beba4 100644
--- a/cmd/api.go
+++ b/cmd/api.go
@@ -6,23 +6,15 @@ import (
 	"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"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"forgejo.zerova.net/public/fgj-sid/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",
@@ -34,22 +26,16 @@ 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
+  fgj api /repos/{owner}/{repo}/pulls
 
   # Create an issue
-  fj api /repos/{owner}/{repo}/issues --method POST --field title=Bug --field body="It broke"
+  fgj api /repos/{owner}/{repo}/issues --method POST --field title=Bug --field body="It broke"
 
   # Get a specific user
-  fj api /users/johndoe
+  fgj 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`,
+  echo '{"title":"test"}' | fgj api /repos/{owner}/{repo}/issues --input -`,
 	Args: cobra.ExactArgs(1),
 	RunE: runAPI,
 }
@@ -64,40 +50,6 @@ func init() {
 	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 {
@@ -187,28 +139,15 @@ func runAPI(cmd *cobra.Command, args []string) error {
 		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)
+	// Build URL
+	baseURL := "https://" + host.Hostname + "/api/v1"
+	if !strings.HasPrefix(endpoint, "/") {
+		endpoint = "/" + endpoint
 	}
-	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
+	url := baseURL + endpoint
 
 	// Create HTTP request
-	req, err := http.NewRequest(method, final.String(), body)
+	req, err := http.NewRequest(method, url, body)
 	if err != nil {
 		return fmt.Errorf("failed to create request: %w", err)
 	}
@@ -231,42 +170,20 @@ func runAPI(cmd *cobra.Command, args []string) error {
 		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)
+	// Execute request
+	ios.StartSpinner("Requesting...")
+	httpClient := &http.Client{}
+	resp, err := httpClient.Do(req)
+	ios.StopSpinner()
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to perform request: %w", err)
 	}
+	defer func() { _ = resp.Body.Close() }()
 
+	// Print response headers if requested
 	if include {
-		fmt.Fprintf(ios.Out, "%s %s\n", proto, status)
-		for key, values := range respHeader {
+		fmt.Fprintf(ios.Out, "%s %s\n", resp.Proto, resp.Status)
+		for key, values := range resp.Header {
 			for _, v := range values {
 				fmt.Fprintf(ios.Out, "%s: %s\n", key, v)
 			}
@@ -274,99 +191,39 @@ func runAPI(cmd *cobra.Command, args []string) error {
 		fmt.Fprintln(ios.Out)
 	}
 
-	if statusCode < 200 || statusCode >= 300 {
+	// Read response body
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	// Handle non-2xx status codes
+	if resp.StatusCode < 200 || resp.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
+		return fmt.Errorf("API request failed with status %d", resp.StatusCode)
 	}
 
 	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 {
+	// Pretty-print JSON, or output raw if not JSON
+	contentType := resp.Header.Get("Content-Type")
+	if strings.Contains(contentType, "json") || json.Valid(respBody) {
 		var parsed any
 		if err := json.Unmarshal(respBody, &parsed); err == nil {
-			return writeJSON(parsed)
+			enc := json.NewEncoder(ios.Out)
+			enc.SetIndent("", "  ")
+			return enc.Encode(parsed)
 		}
 	}
 
+	// Raw output for non-JSON responses
 	_, err = ios.Out.Write(respBody)
 	return err
 }
diff --git a/cmd/auth.go b/cmd/auth.go
index 53ce982..a6b3c74 100644
--- a/cmd/auth.go
+++ b/cmd/auth.go
@@ -7,8 +7,8 @@ import (
 	"strings"
 	"syscall"
 
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"golang.org/x/term"
@@ -16,7 +16,7 @@ import (
 
 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.",
 }
 
@@ -55,25 +55,16 @@ func init() {
 	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")
+	authLogoutCmd.Flags().String("hostname", "", "Forgejo instance hostname (e.g., codeberg.org)")
+	authTokenCmd.Flags().String("hostname", "", "Forgejo instance hostname (e.g., codeberg.org)")
 }
 
 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 == "" {
@@ -141,7 +132,7 @@ 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.Fprintln(ios.Out, "Run 'fgj auth login' to authenticate")
 		return nil
 	}
 
@@ -197,7 +188,7 @@ func resolveAuthHostname(cfg *config.Config, hostname string) (string, error) {
 		hostname = viper.GetString("hostname")
 	}
 	if hostname == "" {
-		hostname = config.EnvWithFallback("FJ_HOST", "FGJ_HOST")
+		hostname = os.Getenv("FGJ_HOST")
 	}
 	if hostname == "" {
 		hostname = getDetectedHost()
diff --git a/cmd/branch.go b/cmd/branch.go
new file mode 100644
index 0000000..a6453af
--- /dev/null
+++ b/cmd/branch.go
@@ -0,0 +1,185 @@
+package cmd
+
+import (
+	"fmt"
+
+	"code.gitea.io/sdk/gitea"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var branchCmd = &cobra.Command{
+	Use:     "branch",
+	Aliases: []string{"b"},
+	Short:   "Manage repository branches",
+	Long:    "List, rename, and delete branches in a repository.",
+}
+
+var branchListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List repository branches",
+	Long:  "List branches in a repository, showing protection status.",
+	Example: `  # List branches in the current repository
+  fgj branch list
+
+  # List branches in a specific repository
+  fgj branch list -R owner/repo
+
+  # Output as JSON
+  fgj branch list --json`,
+	RunE: runBranchList,
+}
+
+var branchRenameCmd = &cobra.Command{
+	Use:   "rename <old-name> <new-name>",
+	Short: "Rename a branch",
+	Long:  "Rename a branch in a repository. Requires Forgejo/Gitea support for branch rename (usually present).",
+	Example: `  # Rename a branch in the current repository
+  fgj branch rename old-name new-name
+
+  # Rename a branch in a specific repository
+  fgj branch rename main trunk -R owner/repo`,
+	Args: cobra.ExactArgs(2),
+	RunE: runBranchRename,
+}
+
+var branchDeleteCmd = &cobra.Command{
+	Use:     "delete <name>",
+	Aliases: []string{"rm"},
+	Short:   "Delete a branch",
+	Long:    "Delete a branch from a repository. Protected branches cannot be deleted.",
+	Example: `  # Delete a branch
+  fgj branch delete feature/old-work
+
+  # Delete without confirmation
+  fgj branch delete feature/old-work -y`,
+	Args: cobra.ExactArgs(1),
+	RunE: runBranchDelete,
+}
+
+func init() {
+	rootCmd.AddCommand(branchCmd)
+	branchCmd.AddCommand(branchListCmd)
+	branchCmd.AddCommand(branchRenameCmd)
+	branchCmd.AddCommand(branchDeleteCmd)
+
+	addRepoFlags(branchListCmd)
+	addJSONFlags(branchListCmd, "Output as JSON")
+
+	addRepoFlags(branchRenameCmd)
+
+	addRepoFlags(branchDeleteCmd)
+	branchDeleteCmd.Flags().BoolP("yes", "y", false, "Skip confirmation prompt")
+}
+
+func runBranchList(cmd *cobra.Command, args []string) error {
+	client, owner, name, err := newBranchClient(cmd)
+	if err != nil {
+		return err
+	}
+
+	branches, _, err := client.ListRepoBranches(owner, name, gitea.ListRepoBranchesOptions{})
+	if err != nil {
+		return fmt.Errorf("failed to list branches: %w", err)
+	}
+
+	if wantJSON(cmd) {
+		return outputJSON(cmd, branches)
+	}
+
+	if len(branches) == 0 {
+		fmt.Fprintln(ios.Out, "No branches found")
+		return nil
+	}
+
+	tp := ios.NewTablePrinter()
+	tp.AddHeader("NAME", "PROTECTED", "COMMIT")
+	for _, b := range branches {
+		protected := ""
+		if b.Protected {
+			protected = "yes"
+		}
+		sha := ""
+		if b.Commit != nil {
+			if len(b.Commit.ID) >= 7 {
+				sha = b.Commit.ID[:7]
+			} else {
+				sha = b.Commit.ID
+			}
+		}
+		tp.AddRow(b.Name, protected, sha)
+	}
+	return tp.Render()
+}
+
+func runBranchRename(cmd *cobra.Command, args []string) error {
+	client, owner, name, err := newBranchClient(cmd)
+	if err != nil {
+		return err
+	}
+
+	oldName, newName := args[0], args[1]
+
+	_, _, err = client.UpdateRepoBranch(owner, name, oldName, gitea.UpdateRepoBranchOption{Name: newName})
+	if err != nil {
+		return fmt.Errorf("failed to rename branch %q to %q: %w", oldName, newName, err)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Renamed branch %q to %q\n", cs.SuccessIcon(), oldName, newName)
+	return nil
+}
+
+func runBranchDelete(cmd *cobra.Command, args []string) error {
+	client, owner, name, err := newBranchClient(cmd)
+	if err != nil {
+		return err
+	}
+
+	branchName := args[0]
+	skipConfirm, _ := cmd.Flags().GetBool("yes")
+
+	if !skipConfirm && ios.IsStdinTTY() {
+		answer, err := promptLine(fmt.Sprintf("Delete branch %q in %s/%s? [y/N]: ", branchName, owner, name))
+		if err != nil {
+			return err
+		}
+		if answer != "y" && answer != "Y" && answer != "yes" {
+			fmt.Fprintln(ios.ErrOut, "Cancelled.")
+			return nil
+		}
+	}
+
+	ok, _, err := client.DeleteRepoBranch(owner, name, branchName)
+	if err != nil {
+		return fmt.Errorf("failed to delete branch %q: %w", branchName, err)
+	}
+	if !ok {
+		return fmt.Errorf("branch %q was not deleted (it may be protected or not exist)", branchName)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Deleted branch %q\n", cs.SuccessIcon(), branchName)
+	return nil
+}
+
+func newBranchClient(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
+}
diff --git a/cmd/branch_protect.go b/cmd/branch_protect.go
new file mode 100644
index 0000000..4878954
--- /dev/null
+++ b/cmd/branch_protect.go
@@ -0,0 +1,204 @@
+package cmd
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/spf13/cobra"
+)
+
+var branchProtectCmd = &cobra.Command{
+	Use:   "protect <branch-name>",
+	Short: "Protect a branch",
+	Long: `Create or update a branch protection rule for the given branch.
+
+If a protection rule already exists for the branch it is updated in place;
+otherwise a new one is created. Fields you do not set on the command line
+are left at their server-side defaults (or left unchanged when editing).`,
+	Example: `  # Require 2 approving reviews before merging
+  fgj branch protect main --require-approvals 2
+
+  # Dismiss stale approvals and require signed commits
+  fgj branch protect main --dismiss-stale-approvals --require-signed-commits
+
+  # Allow specific users to push directly, and require CI contexts
+  fgj branch protect main \
+    --push-whitelist alice,bob \
+    --require-status-checks ci/build,ci/test`,
+	Args: cobra.ExactArgs(1),
+	RunE: runBranchProtect,
+}
+
+var branchUnprotectCmd = &cobra.Command{
+	Use:   "unprotect <branch-name>",
+	Short: "Remove a branch protection rule",
+	Long:  "Remove the protection rule attached to a branch. If the branch has no protection this is a no-op.",
+	Example: `  # Remove protection interactively
+  fgj branch unprotect main
+
+  # Remove without confirmation
+  fgj branch unprotect main -y`,
+	Args: cobra.ExactArgs(1),
+	RunE: runBranchUnprotect,
+}
+
+func init() {
+	branchCmd.AddCommand(branchProtectCmd)
+	branchCmd.AddCommand(branchUnprotectCmd)
+
+	addRepoFlags(branchProtectCmd)
+	branchProtectCmd.Flags().Int64("require-approvals", 0, "Minimum number of approving reviews required")
+	branchProtectCmd.Flags().Bool("dismiss-stale-approvals", false, "Dismiss stale approvals when new commits are pushed")
+	branchProtectCmd.Flags().Bool("require-signed-commits", false, "Require commits on the branch to be signed")
+	branchProtectCmd.Flags().Bool("block-on-rejected-reviews", false, "Block merges when a review requests changes")
+	branchProtectCmd.Flags().Bool("block-on-outdated-branch", false, "Require the PR branch to be up-to-date with the base")
+	branchProtectCmd.Flags().StringSlice("push-whitelist", nil, "Usernames allowed to push directly (comma-separated or repeatable)")
+	branchProtectCmd.Flags().StringSlice("merge-whitelist", nil, "Usernames allowed to merge (comma-separated or repeatable)")
+	branchProtectCmd.Flags().StringSlice("require-status-checks", nil, "CI status contexts that must pass (comma-separated or repeatable)")
+	addJSONFlags(branchProtectCmd, "Output the resulting protection rule as JSON")
+
+	addRepoFlags(branchUnprotectCmd)
+	branchUnprotectCmd.Flags().BoolP("yes", "y", false, "Skip confirmation prompt")
+}
+
+func runBranchProtect(cmd *cobra.Command, args []string) error {
+	client, owner, name, err := newBranchClient(cmd)
+	if err != nil {
+		return err
+	}
+
+	branchName := args[0]
+
+	requireApprovals, _ := cmd.Flags().GetInt64("require-approvals")
+	dismissStale, _ := cmd.Flags().GetBool("dismiss-stale-approvals")
+	requireSigned, _ := cmd.Flags().GetBool("require-signed-commits")
+	blockRejected, _ := cmd.Flags().GetBool("block-on-rejected-reviews")
+	blockOutdated, _ := cmd.Flags().GetBool("block-on-outdated-branch")
+	pushWhitelist, _ := cmd.Flags().GetStringSlice("push-whitelist")
+	mergeWhitelist, _ := cmd.Flags().GetStringSlice("merge-whitelist")
+	statusChecks, _ := cmd.Flags().GetStringSlice("require-status-checks")
+
+	// Check whether a protection rule already exists for this branch.
+	existing, resp, getErr := client.GetBranchProtection(owner, name, branchName)
+	exists := getErr == nil && existing != nil
+	if getErr != nil && !isNotFound(resp, getErr) {
+		return fmt.Errorf("failed to look up branch protection for %q: %w", branchName, getErr)
+	}
+
+	var result *gitea.BranchProtection
+
+	if exists {
+		edit := gitea.EditBranchProtectionOption{
+			RequiredApprovals:      &requireApprovals,
+			DismissStaleApprovals:  &dismissStale,
+			RequireSignedCommits:   &requireSigned,
+			BlockOnRejectedReviews: &blockRejected,
+			BlockOnOutdatedBranch:  &blockOutdated,
+		}
+		if len(pushWhitelist) > 0 {
+			enable := true
+			edit.EnablePushWhitelist = &enable
+			edit.PushWhitelistUsernames = pushWhitelist
+		}
+		if len(mergeWhitelist) > 0 {
+			enable := true
+			edit.EnableMergeWhitelist = &enable
+			edit.MergeWhitelistUsernames = mergeWhitelist
+		}
+		if len(statusChecks) > 0 {
+			enable := true
+			edit.EnableStatusCheck = &enable
+			edit.StatusCheckContexts = statusChecks
+		}
+
+		bp, _, err := client.EditBranchProtection(owner, name, branchName, edit)
+		if err != nil {
+			return fmt.Errorf("failed to update branch protection for %q: %w", branchName, err)
+		}
+		result = bp
+	} else {
+		create := gitea.CreateBranchProtectionOption{
+			BranchName:             branchName,
+			RequiredApprovals:      requireApprovals,
+			DismissStaleApprovals:  dismissStale,
+			RequireSignedCommits:   requireSigned,
+			BlockOnRejectedReviews: blockRejected,
+			BlockOnOutdatedBranch:  blockOutdated,
+		}
+		if len(pushWhitelist) > 0 {
+			create.EnablePushWhitelist = true
+			create.PushWhitelistUsernames = pushWhitelist
+		}
+		if len(mergeWhitelist) > 0 {
+			create.EnableMergeWhitelist = true
+			create.MergeWhitelistUsernames = mergeWhitelist
+		}
+		if len(statusChecks) > 0 {
+			create.EnableStatusCheck = true
+			create.StatusCheckContexts = statusChecks
+		}
+
+		bp, _, err := client.CreateBranchProtection(owner, name, create)
+		if err != nil {
+			return fmt.Errorf("failed to create branch protection for %q: %w", branchName, err)
+		}
+		result = bp
+	}
+
+	if wantJSON(cmd) {
+		return outputJSON(cmd, result)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Protected branch %q\n", cs.SuccessIcon(), branchName)
+	return nil
+}
+
+func runBranchUnprotect(cmd *cobra.Command, args []string) error {
+	client, owner, name, err := newBranchClient(cmd)
+	if err != nil {
+		return err
+	}
+
+	branchName := args[0]
+	skipConfirm, _ := cmd.Flags().GetBool("yes")
+
+	if !skipConfirm && ios.IsStdinTTY() {
+		answer, err := promptLine(fmt.Sprintf("Remove protection from branch %q in %s/%s? [y/N]: ", branchName, owner, name))
+		if err != nil {
+			return err
+		}
+		if answer != "y" && answer != "Y" && answer != "yes" {
+			fmt.Fprintln(ios.ErrOut, "Cancelled.")
+			return nil
+		}
+	}
+
+	resp, err := client.DeleteBranchProtection(owner, name, branchName)
+	if err != nil {
+		if isNotFound(resp, err) {
+			fmt.Fprintf(ios.Out, "Branch %q has no protection rule; nothing to do.\n", branchName)
+			return nil
+		}
+		return fmt.Errorf("failed to remove branch protection for %q: %w", branchName, err)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Removed protection from branch %q\n", cs.SuccessIcon(), branchName)
+	return nil
+}
+
+// isNotFound reports whether a gitea SDK call failed with a 404. The SDK
+// sometimes returns a nil Response on transport-level errors, so we fall back
+// to a string check on the error message in that case.
+func isNotFound(resp *gitea.Response, err error) bool {
+	if err == nil {
+		return false
+	}
+	if resp != nil && resp.Response != nil && resp.StatusCode == http.StatusNotFound {
+		return true
+	}
+	return strings.Contains(err.Error(), "404")
+}
diff --git a/cmd/completion.go b/cmd/completion.go
index 6a19f98..6ead4b8 100644
--- a/cmd/completion.go
+++ b/cmd/completion.go
@@ -11,7 +11,7 @@ import (
 var completionCmd = &cobra.Command{
 	Use:                   "completion [bash|zsh|fish|powershell]",
 	Short:                 "Generate shell completion scripts",
-	Long:                  "Generate shell completion scripts for fj.",
+	Long:                  "Generate shell completion scripts for fgj.",
 	Args:                  cobra.MatchAll(cobra.ExactArgs(1), cobra.OnlyValidArgs),
 	ValidArgs:             []string{"bash", "zsh", "fish", "powershell"},
 	DisableFlagsInUseLine: true,
diff --git a/cmd/completion_install.go b/cmd/completion_install.go
new file mode 100644
index 0000000..c45c870
--- /dev/null
+++ b/cmd/completion_install.go
@@ -0,0 +1,188 @@
+package cmd
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+var completionInstallCmd = &cobra.Command{
+	Use:       "install [shell]",
+	Short:     "Install shell completions to a standard location",
+	Long:      "Install shell completions for fgj to a shell-appropriate location. If [shell] is omitted, it is detected from $SHELL. Supported: bash, zsh, fish.",
+	Args:      cobra.MaximumNArgs(1),
+	ValidArgs: []string{"bash", "zsh", "fish"},
+	RunE:      runCompletionInstall,
+}
+
+func init() {
+	completionCmd.AddCommand(completionInstallCmd)
+	completionInstallCmd.Flags().Bool("system", false, "Install system-wide (bash only; prints required sudo command)")
+	completionInstallCmd.Flags().Bool("dry-run", false, "Print the target path and exit without writing")
+}
+
+func runCompletionInstall(cmd *cobra.Command, args []string) error {
+	shell := ""
+	if len(args) == 1 {
+		shell = args[0]
+	} else {
+		detected, err := detectShell()
+		if err != nil {
+			return err
+		}
+		shell = detected
+	}
+
+	switch shell {
+	case "bash", "zsh", "fish":
+		// supported
+	case "powershell":
+		return fmt.Errorf("powershell auto-install is not supported; run `fgj completion powershell` and save the output manually")
+	default:
+		return fmt.Errorf("unsupported shell: %s (supported: bash, zsh, fish)", shell)
+	}
+
+	system, _ := cmd.Flags().GetBool("system")
+	dryRun, _ := cmd.Flags().GetBool("dry-run")
+
+	// Generate completion script into a buffer.
+	var buf bytes.Buffer
+	switch shell {
+	case "bash":
+		if err := rootCmd.GenBashCompletion(&buf); err != nil {
+			return fmt.Errorf("failed to generate bash completions: %w", err)
+		}
+	case "zsh":
+		if err := rootCmd.GenZshCompletion(&buf); err != nil {
+			return fmt.Errorf("failed to generate zsh completions: %w", err)
+		}
+	case "fish":
+		if err := rootCmd.GenFishCompletion(&buf, true); err != nil {
+			return fmt.Errorf("failed to generate fish completions: %w", err)
+		}
+	}
+
+	// Resolve the target path.
+	targetPath, sudoHint, err := completionTargetPath(shell, system)
+	if err != nil {
+		return err
+	}
+
+	if sudoHint != "" {
+		// System-wide bash path requires root. Print the command and exit.
+		fmt.Fprintf(ios.Out, "System-wide install requires root. Run:\n  %s\n", sudoHint)
+		return nil
+	}
+
+	if dryRun {
+		fmt.Fprintln(ios.Out, targetPath)
+		return nil
+	}
+
+	// Create parent directory.
+	if err := os.MkdirAll(filepath.Dir(targetPath), 0o755); err != nil {
+		return fmt.Errorf("failed to create %s: %w", filepath.Dir(targetPath), err)
+	}
+
+	// Idempotent write: if the file already exists and matches, skip.
+	if existing, err := os.ReadFile(targetPath); err == nil {
+		if bytes.Equal(existing, buf.Bytes()) {
+			fmt.Fprintf(ios.Out, "Completion already installed at %s (up to date)\n", targetPath)
+			return nil
+		}
+	}
+
+	if err := os.WriteFile(targetPath, buf.Bytes(), 0o644); err != nil {
+		return fmt.Errorf("failed to write %s: %w", targetPath, err)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Installed %s completions to %s\n", cs.SuccessIcon(), shell, targetPath)
+
+	if shell == "zsh" {
+		fmt.Fprintln(ios.Out, "")
+		fmt.Fprintln(ios.Out, "If you haven't already, add the following to your ~/.zshrc:")
+		fmt.Fprintln(ios.Out, "  fpath=(~/.zsh/completions $fpath)")
+		fmt.Fprintln(ios.Out, "  autoload -U compinit && compinit")
+	}
+
+	return nil
+}
+
+// completionTargetPath resolves the target install path for the given shell.
+// For bash system-wide installs, it returns an empty path and a sudo hint command
+// that the caller should print instead of writing.
+func completionTargetPath(shell string, system bool) (string, string, error) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", "", fmt.Errorf("failed to resolve home directory: %w", err)
+	}
+
+	switch shell {
+	case "bash":
+		if system {
+			if _, err := os.Stat("/etc/bash_completion.d"); err == nil {
+				exe, exeErr := os.Executable()
+				if exeErr != nil || exe == "" {
+					exe = "fgj"
+				}
+				sudo := fmt.Sprintf("sudo sh -c '%s completion bash > /etc/bash_completion.d/fgj'", exe)
+				return "", sudo, nil
+			}
+			return "", "", fmt.Errorf("--system requested but /etc/bash_completion.d does not exist")
+		}
+		if runtime.GOOS == "darwin" {
+			if prefix, ok := brewPrefix(); ok {
+				return filepath.Join(prefix, "etc", "bash_completion.d", "fgj"), "", nil
+			}
+		}
+		xdg := os.Getenv("XDG_DATA_HOME")
+		if xdg == "" {
+			xdg = filepath.Join(home, ".local", "share")
+		}
+		return filepath.Join(xdg, "bash-completion", "completions", "fgj"), "", nil
+
+	case "zsh":
+		zdot := os.Getenv("ZDOTDIR")
+		if zdot == "" {
+			zdot = home
+		}
+		return filepath.Join(zdot, ".zsh", "completions", "_fgj"), "", nil
+
+	case "fish":
+		return filepath.Join(home, ".config", "fish", "completions", "fgj.fish"), "", nil
+	}
+
+	return "", "", fmt.Errorf("unsupported shell: %s", shell)
+}
+
+// detectShell reads $SHELL and returns its basename.
+func detectShell() (string, error) {
+	s := os.Getenv("SHELL")
+	if s == "" {
+		return "", fmt.Errorf("cannot detect shell: $SHELL is empty (pass shell name explicitly)")
+	}
+	return filepath.Base(s), nil
+}
+
+// brewPrefix returns the Homebrew prefix if brew is available on PATH.
+func brewPrefix() (string, bool) {
+	if _, err := exec.LookPath("brew"); err != nil {
+		return "", false
+	}
+	out, err := exec.Command("brew", "--prefix").Output()
+	if err != nil {
+		return "", false
+	}
+	prefix := strings.TrimSpace(string(out))
+	if prefix == "" {
+		return "", false
+	}
+	return prefix, true
+}
diff --git a/cmd/errors.go b/cmd/errors.go
index 7617430..e303e6e 100644
--- a/cmd/errors.go
+++ b/cmd/errors.go
@@ -3,9 +3,10 @@ package cmd
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"strings"
 
-	"forgejo.zerova.net/public/fj/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
 )
 
 // Error codes for structured error output.
@@ -24,15 +25,9 @@ type CLIError struct {
 	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
 }
 
@@ -47,59 +42,46 @@ func NewAPIError(status int, message string) *CLIError {
 }
 
 // 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) {
+	msg := err.Error()
+
+	// Check for API errors with status codes
+	var apiErr *api.APIError
+	if errors.As(err, &apiErr) {
+		switch {
+		case apiErr.StatusCode == 401 || apiErr.StatusCode == 403:
+			return fmt.Errorf("%w\nHint: Try authenticating with: fgj auth login", err)
+		case apiErr.StatusCode == 404:
+			return fmt.Errorf("%w\nHint: Resource not found. Check the repository and number are correct.", err)
+		}
 		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
+	// Check for network/connection errors
+	switch {
+	case strings.Contains(msg, "no such host"):
+		return fmt.Errorf("%w\nHint: Check your internet connection and that the host is correct.", err)
+	case strings.Contains(msg, "connection refused"):
+		return fmt.Errorf("%w\nHint: Check your internet connection and that the host is correct.", err)
 	}
 
-	// Plain network errors come back as fmt.Errorf strings from net/http.
-	msg := err.Error()
+	// Check for string-based status code patterns (from wrapped errors)
 	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.",
+	case strings.Contains(msg, "401") || strings.Contains(msg, "403"):
+		if strings.Contains(msg, "authentication") || strings.Contains(msg, "unauthorized") || strings.Contains(msg, "forbidden") {
+			return fmt.Errorf("%w\nHint: Try authenticating with: fgj auth login", err)
 		}
 	}
 
 	return err
 }
 
+// writeJSONError writes a structured JSON error to stderr.
+// It attempts to extract structured info from known error types.
 // WriteJSONError writes a structured JSON error to stderr.
 // It is exported for use from main.go.
 func WriteJSONError(err error) {
@@ -108,9 +90,7 @@ func WriteJSONError(err error) {
 		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.
+	// Try to extract structured info from the error chain.
 	var apiErr *api.APIError
 	var cErr *CLIError
 
@@ -125,6 +105,8 @@ func WriteJSONError(err error) {
 			cliErr.Code = ErrAuthRequired
 		case apiErr.StatusCode == 404:
 			cliErr.Code = ErrNotFound
+		default:
+			cliErr.Code = ErrAPIError
 		}
 	}
 
@@ -132,6 +114,3 @@ func WriteJSONError(err error) {
 	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
index e4f04c5..9d36650 100644
--- a/cmd/ios_init.go
+++ b/cmd/ios_init.go
@@ -1,5 +1,5 @@
 package cmd
 
-import "forgejo.zerova.net/public/fj/internal/iostreams"
+import "forgejo.zerova.net/public/fgj-sid/internal/iostreams"
 
 var ios = iostreams.New()
diff --git a/cmd/issue.go b/cmd/issue.go
index 25f54f3..d29f4fe 100644
--- a/cmd/issue.go
+++ b/cmd/issue.go
@@ -4,11 +4,12 @@ import (
 	"fmt"
 	"net/http"
 	"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"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"forgejo.zerova.net/public/fgj-sid/internal/text"
 	"github.com/spf13/cobra"
 )
 
@@ -23,13 +24,19 @@ var issueListCmd = &cobra.Command{
 	Short: "List issues",
 	Long:  "List issues in a repository.",
 	Example: `  # List open issues
-  fj issue list
+  fgj issue list
 
   # List closed issues for a specific repo
-  fj issue list -s closed -R owner/repo
+  fgj issue list -s closed -R owner/repo
 
   # Output as JSON
-  fj issue list --json`,
+  fgj issue list --json
+
+  # PRs updated in the last 7 days
+  fgj pr list --since 7d
+
+  # Issues touched between two dates
+  fgj issue list --since 2026-04-01 --before 2026-04-15`,
 	RunE: runIssueList,
 }
 
@@ -38,16 +45,16 @@ var issueViewCmd = &cobra.Command{
 	Short: "View an issue",
 	Long:  "Display detailed information about an issue.",
 	Example: `  # View issue #42
-  fj issue view 42
+  fgj issue view 42
 
   # View using URL
-  fj issue view https://codeberg.org/owner/repo/issues/42
+  fgj issue view https://codeberg.org/owner/repo/issues/42
 
   # Open in browser
-  fj issue view 42 --web
+  fgj issue view 42 --web
 
   # View an issue from a specific repo as JSON
-  fj issue view 42 -R owner/repo --json`,
+  fgj issue view 42 -R owner/repo --json`,
 	Args: cobra.ExactArgs(1),
 	RunE: runIssueView,
 }
@@ -57,10 +64,10 @@ var issueCreateCmd = &cobra.Command{
 	Short: "Create an issue",
 	Long:  "Create a new issue.",
 	Example: `  # Create an issue with a title
-  fj issue create -t "Fix login bug"
+  fgj 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`,
+  fgj issue create -t "Add dark mode" -b "We need a dark theme" -l feature -l ui`,
 	RunE: runIssueCreate,
 }
 
@@ -69,10 +76,10 @@ var issueCommentCmd = &cobra.Command{
 	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"
+  fgj 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`,
+  fgj issue comment 10 -b "Confirmed on my end" -R owner/repo`,
 	Args: cobra.ExactArgs(1),
 	RunE: runIssueComment,
 }
@@ -82,10 +89,10 @@ var issueCloseCmd = &cobra.Command{
 	Short: "Close an issue",
 	Long:  "Close an existing issue.",
 	Example: `  # Close issue #42
-  fj issue close 42
+  fgj issue close 42
 
   # Close with a comment
-  fj issue close 42 -c "Fixed in commit abc1234"`,
+  fgj issue close 42 -c "Fixed in commit abc1234"`,
 	Args: cobra.ExactArgs(1),
 	RunE: runIssueClose,
 }
@@ -95,7 +102,7 @@ var issueReopenCmd = &cobra.Command{
 	Short: "Reopen an issue",
 	Long:  "Reopen a closed issue.",
 	Example: `  # Reopen issue #42
-  fj issue reopen 42`,
+  fgj issue reopen 42`,
 	Args: cobra.ExactArgs(1),
 	RunE: runIssueReopen,
 }
@@ -105,10 +112,10 @@ var issueDeleteCmd = &cobra.Command{
 	Short: "Delete an issue",
 	Long:  "Delete an issue permanently.",
 	Example: `  # Delete issue #42
-  fj issue delete 42
+  fgj issue delete 42
 
   # Delete without confirmation
-  fj issue delete 42 -y`,
+  fgj issue delete 42 -y`,
 	Args: cobra.ExactArgs(1),
 	RunE: runIssueDelete,
 }
@@ -118,16 +125,16 @@ var issueEditCmd = &cobra.Command{
 	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"
+  fgj issue edit 42 -t "Updated title"
 
   # Reopen a closed issue
-  fj issue edit 42 -s open
+  fgj issue edit 42 -s open
 
   # Add and remove labels
-  fj issue edit 42 --add-label bug --remove-label wontfix
+  fgj issue edit 42 --add-label bug --remove-label wontfix
 
   # Add a dependency
-  fj issue edit 42 --add-dependency 10`,
+  fgj issue edit 42 --add-dependency 10`,
 	Args: cobra.ExactArgs(1),
 	RunE: runIssueEdit,
 }
@@ -152,6 +159,8 @@ func init() {
 	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")
+	issueListCmd.Flags().String("since", "", "Only items updated at or after this date (YYYY-MM-DD, RFC 3339, or relative like 7d)")
+	issueListCmd.Flags().String("before", "", "Only items updated strictly before this date (YYYY-MM-DD, RFC 3339, or relative like 1d)")
 	addJSONFlags(issueListCmd, "Output issues as JSON")
 
 	issueViewCmd.Flags().StringP("repo", "R", "", "Repository in owner/name format")
@@ -192,6 +201,24 @@ func runIssueList(cmd *cobra.Command, args []string) error {
 	author, _ := cmd.Flags().GetString("author")
 	labels, _ := cmd.Flags().GetStringSlice("label")
 	search, _ := cmd.Flags().GetString("search")
+	sinceStr, _ := cmd.Flags().GetString("since")
+	beforeStr, _ := cmd.Flags().GetString("before")
+
+	var sinceTime, beforeTime time.Time
+	if sinceStr != "" {
+		t, err := parseDateArg(sinceStr)
+		if err != nil {
+			return fmt.Errorf("invalid --since: %w", err)
+		}
+		sinceTime = t
+	}
+	if beforeStr != "" {
+		t, err := parseDateArg(beforeStr)
+		if err != nil {
+			return fmt.Errorf("invalid --before: %w", err)
+		}
+		beforeTime = t
+	}
 
 	owner, name, err := parseRepo(repo)
 	if err != nil {
@@ -221,24 +248,15 @@ func runIssueList(cmd *cobra.Command, args []string) error {
 	}
 
 	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,
+		Labels:      labels,
+		KeyWord:     search,
+		CreatedBy:   author,
+		AssignedBy:  assignee,
+		Since:       sinceTime,
+		Before:      beforeTime,
+		ListOptions: gitea.ListOptions{PageSize: limit},
 	})
 	ios.StopSpinner()
 	if err != nil {
@@ -251,9 +269,6 @@ func runIssueList(cmd *cobra.Command, args []string) error {
 			nonPRIssues = append(nonPRIssues, issue)
 		}
 	}
-	if limit > 0 && len(nonPRIssues) > limit {
-		nonPRIssues = nonPRIssues[:limit]
-	}
 
 	if wantJSON(cmd) {
 		return outputJSON(cmd, nonPRIssues)
diff --git a/cmd/json.go b/cmd/json.go
index 70ac0be..2472449 100644
--- a/cmd/json.go
+++ b/cmd/json.go
@@ -10,48 +10,47 @@ import (
 )
 
 // addJSONFlags adds --json, --json-fields, and --jq flags to a command.
+// --json is an optional-value string flag:
+//   - --json (no value) → output all fields as JSON
+//   - --json title,state → output only those fields (gh-compatible)
 //
-// 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").
+// --json-fields is kept as a backwards-compatible alias.
 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("json", "", jsonDesc)
+	f.Lookup("json").NoOptDefVal = " " // space sentinel: flag present with no value
+	f.String("json-fields", "", "Comma-separated list of JSON fields to include")
 	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.
+// 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 != "" {
+	if j, _ := cmd.Flags().GetString("json"); j != "" {
 		return true
 	}
 	if jq, _ := cmd.Flags().GetString("jq"); jq != "" {
 		return true
 	}
+	if f, _ := cmd.Flags().GetString("json-fields"); f != "" {
+		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.
+// outputJSON writes a value as JSON, respecting --json, --json-fields, and --jq flags.
 func outputJSON(cmd *cobra.Command, value any) error {
-	fields, _ := cmd.Flags().GetString("json-fields")
+	jsonVal, _ := cmd.Flags().GetString("json")
+	jsonFields, _ := cmd.Flags().GetString("json-fields")
 	jqExpr, _ := cmd.Flags().GetString("jq")
+
+	fields := ""
+	jsonVal = strings.TrimSpace(jsonVal)
+	if jsonVal != "" {
+		fields = jsonVal
+	} else if jsonFields != "" {
+		fields = jsonFields
+	}
+
 	return writeJSONFiltered(value, fields, jqExpr)
 }
 
diff --git a/cmd/label.go b/cmd/label.go
index 96cb632..f496711 100644
--- a/cmd/label.go
+++ b/cmd/label.go
@@ -5,8 +5,8 @@ import (
 	"strings"
 
 	"code.gitea.io/sdk/gitea"
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
 	"github.com/spf13/cobra"
 )
 
@@ -21,13 +21,13 @@ var labelListCmd = &cobra.Command{
 	Short: "List labels for a repository",
 	Long:  "List all labels defined in a repository.",
 	Example: `  # List labels for the current repository
-  fj label list
+  fgj label list
 
   # List labels for a specific repository
-  fj label list -R owner/repo
+  fgj label list -R owner/repo
 
   # Output as JSON
-  fj label list --json`,
+  fgj label list --json`,
 	RunE: runLabelList,
 }
 
@@ -36,29 +36,30 @@ var labelCreateCmd = &cobra.Command{
 	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
+  fgj label create bug -c ff0000
 
   # Create a label with color and description
-  fj label create feature -c 00ff00 -d "New feature request"
+  fgj 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`,
+  fgj 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.",
+	Use:     "edit <name>",
+	Aliases: []string{"update"},
+	Short:   "Edit a label",
+	Long:    "Edit an existing label in a repository.",
 	Example: `  # Rename a label
-  fj label edit bug --name bugfix
+  fgj label edit bug --name bugfix
 
   # Change the color of a label
-  fj label edit bug -c 00ff00
+  fgj label edit bug -c 00ff00
 
   # Update description
-  fj label edit bug -d "Something is broken"`,
+  fgj label edit bug -d "Something is broken"`,
 	Args: cobra.ExactArgs(1),
 	RunE: runLabelEdit,
 }
@@ -68,13 +69,13 @@ var labelDeleteCmd = &cobra.Command{
 	Short: "Delete a label",
 	Long:  "Delete a label from a repository.",
 	Example: `  # Delete a label
-  fj label delete bug
+  fgj label delete bug
 
   # Delete without confirmation
-  fj label delete bug -y
+  fgj label delete bug -y
 
   # Delete a label from a specific repository
-  fj label delete bug -R owner/repo`,
+  fgj label delete bug -R owner/repo`,
 	Args: cobra.ExactArgs(1),
 	RunE: runLabelDelete,
 }
diff --git a/cmd/logins.go b/cmd/logins.go
new file mode 100644
index 0000000..73dea59
--- /dev/null
+++ b/cmd/logins.go
@@ -0,0 +1,160 @@
+package cmd
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var loginsCmd = &cobra.Command{
+	Use:   "logins",
+	Short: "Manage configured Forgejo/Gitea logins",
+	Long: `Manage configured Forgejo/Gitea logins.
+
+This is a complementary command to 'fgj auth' using the noun vocabulary
+familiar to users of tea. Use 'fgj auth login' to add a new login and
+'fgj auth logout' to remove one.`,
+}
+
+var loginsListCmd = &cobra.Command{
+	Use:     "list",
+	Aliases: []string{"ls"},
+	Short:   "List all configured logins",
+	Long:    "List all configured Forgejo/Gitea logins with their hostname, user, protocol, default flag, and match_dirs.",
+	RunE:    runLoginsList,
+}
+
+var loginsDefaultCmd = &cobra.Command{
+	Use:   "default [hostname]",
+	Short: "Get or set the default login",
+	Long: `Get or set the default login.
+
+With no argument, prints the currently-configured default hostname
+(or "no default set" if none is configured).
+
+With a hostname argument, marks that login as the default and unsets
+the default flag on all other logins.`,
+	Args: cobra.MaximumNArgs(1),
+	RunE: runLoginsDefault,
+}
+
+func init() {
+	rootCmd.AddCommand(loginsCmd)
+	loginsCmd.AddCommand(loginsListCmd)
+	loginsCmd.AddCommand(loginsDefaultCmd)
+
+	addJSONFlags(loginsListCmd, "Output logins as JSON")
+}
+
+// loginEntry is the JSON representation of a configured login.
+type loginEntry struct {
+	Hostname    string   `json:"hostname"`
+	User        string   `json:"user"`
+	GitProtocol string   `json:"git_protocol"`
+	Default     bool     `json:"default"`
+	MatchDirs   []string `json:"match_dirs"`
+}
+
+func runLoginsList(cmd *cobra.Command, args []string) error {
+	cfg, err := config.Load()
+	if err != nil {
+		return fmt.Errorf("failed to load config: %w", err)
+	}
+
+	hostnames := make([]string, 0, len(cfg.Hosts))
+	for hostname := range cfg.Hosts {
+		hostnames = append(hostnames, hostname)
+	}
+
+	// Sort by config-file order; fall back to alphabetical when Order is
+	// equal (e.g., both zero because the config was constructed in-memory
+	// rather than loaded from disk).
+	sort.Slice(hostnames, func(i, j int) bool {
+		a, b := cfg.Hosts[hostnames[i]], cfg.Hosts[hostnames[j]]
+		if a.Order != b.Order {
+			return a.Order < b.Order
+		}
+		return hostnames[i] < hostnames[j]
+	})
+
+	if wantJSON(cmd) {
+		entries := make([]loginEntry, 0, len(hostnames))
+		for _, hostname := range hostnames {
+			h := cfg.Hosts[hostname]
+			dirs := h.MatchDirs
+			if dirs == nil {
+				dirs = []string{}
+			}
+			entries = append(entries, loginEntry{
+				Hostname:    hostname,
+				User:        h.User,
+				GitProtocol: h.GitProtocol,
+				Default:     h.Default,
+				MatchDirs:   dirs,
+			})
+		}
+		return outputJSON(cmd, entries)
+	}
+
+	if len(hostnames) == 0 {
+		fmt.Fprintln(ios.Out, "No logins configured")
+		fmt.Fprintln(ios.Out, "Run 'fgj auth login' to add a login")
+		return nil
+	}
+
+	tp := ios.NewTablePrinter()
+	tp.AddHeader("HOSTNAME", "USER", "PROTOCOL", "DEFAULT", "MATCH_DIRS")
+	for _, hostname := range hostnames {
+		h := cfg.Hosts[hostname]
+		defaultMark := ""
+		if h.Default {
+			defaultMark = "*"
+		}
+		tp.AddRow(
+			hostname,
+			h.User,
+			h.GitProtocol,
+			defaultMark,
+			strings.Join(h.MatchDirs, ", "),
+		)
+	}
+	return tp.Render()
+}
+
+func runLoginsDefault(cmd *cobra.Command, args []string) error {
+	cfg, err := config.Load()
+	if err != nil {
+		return fmt.Errorf("failed to load config: %w", err)
+	}
+
+	if len(args) == 0 {
+		current := cfg.DefaultHost()
+		if current == "" {
+			fmt.Fprintln(ios.Out, "no default set")
+			return nil
+		}
+		fmt.Fprintln(ios.Out, current)
+		return nil
+	}
+
+	target := args[0]
+	if _, ok := cfg.Hosts[target]; !ok {
+		return fmt.Errorf("no configuration found for host %s", target)
+	}
+
+	for hostname, h := range cfg.Hosts {
+		h.Default = (hostname == target)
+		cfg.Hosts[hostname] = h
+	}
+
+	if err := cfg.Save(); err != nil {
+		return fmt.Errorf("failed to save config: %w", err)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Default host set to %s\n", cs.SuccessIcon(), target)
+	return nil
+}
diff --git a/cmd/manpages.go b/cmd/manpages.go
index b1124f1..5fc7e10 100644
--- a/cmd/manpages.go
+++ b/cmd/manpages.go
@@ -12,7 +12,7 @@ import (
 var manpagesCmd = &cobra.Command{
 	Use:   "manpages",
 	Short: "Generate manpages",
-	Long:  "Generate manpages for fj commands.",
+	Long:  "Generate manpages for fgj commands.",
 	RunE: func(cmd *cobra.Command, args []string) error {
 		dir, _ := cmd.Flags().GetString("dir")
 		if dir == "" {
@@ -29,7 +29,7 @@ var manpagesCmd = &cobra.Command{
 		}
 
 		header := &doc.GenManHeader{
-			Title:   "FJ",
+			Title:   "FGJ",
 			Section: "1",
 		}
 
diff --git a/cmd/milestone.go b/cmd/milestone.go
index a10e6a0..ce9813c 100644
--- a/cmd/milestone.go
+++ b/cmd/milestone.go
@@ -7,9 +7,9 @@ import (
 	"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"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"forgejo.zerova.net/public/fgj-sid/internal/text"
 	"github.com/spf13/cobra"
 )
 
@@ -24,13 +24,13 @@ var milestoneListCmd = &cobra.Command{
 	Short: "List milestones",
 	Long:  "List milestones in a repository.",
 	Example: `  # List open milestones
-  fj milestone list
+  fgj milestone list
 
   # List all milestones for a specific repo
-  fj milestone list -R owner/repo --state all
+  fgj milestone list -R owner/repo --state all
 
   # Output as JSON
-  fj milestone list --json`,
+  fgj milestone list --json`,
 	RunE: runMilestoneList,
 }
 
@@ -39,16 +39,16 @@ var milestoneViewCmd = &cobra.Command{
 	Short: "View a milestone",
 	Long:  "Display detailed information about a milestone.",
 	Example: `  # View by ID
-  fj milestone view 1
+  fgj milestone view 1
 
   # View by title
-  fj milestone view "v1.0"
+  fgj milestone view "v1.0"
 
   # Open in browser
-  fj milestone view "v1.0" --web
+  fgj milestone view "v1.0" --web
 
   # Output as JSON
-  fj milestone view "v1.0" --json`,
+  fgj milestone view "v1.0" --json`,
 	Args: cobra.ExactArgs(1),
 	RunE: runMilestoneView,
 }
@@ -58,13 +58,13 @@ var milestoneCreateCmd = &cobra.Command{
 	Short: "Create a milestone",
 	Long:  "Create a new milestone.",
 	Example: `  # Create a simple milestone
-  fj milestone create "v1.0"
+  fgj milestone create "v1.0"
 
   # Create with description and due date
-  fj milestone create "v2.0" -d "Second release" --due 2026-06-01
+  fgj milestone create "v2.0" -d "Second release" --due 2026-06-01
 
   # Output as JSON
-  fj milestone create "v1.0" --json`,
+  fgj milestone create "v1.0" --json`,
 	Args: cobra.ExactArgs(1),
 	RunE: runMilestoneCreate,
 }
@@ -74,13 +74,13 @@ var milestoneEditCmd = &cobra.Command{
 	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"
+  fgj milestone edit "v1.0" --title "v1.1"
 
   # Close a milestone
-  fj milestone edit "v1.0" --state closed
+  fgj milestone edit "v1.0" --state closed
 
   # Update due date
-  fj milestone edit 1 --due 2026-12-31`,
+  fgj milestone edit 1 --due 2026-12-31`,
 	Args: cobra.ExactArgs(1),
 	RunE: runMilestoneEdit,
 }
@@ -90,13 +90,13 @@ var milestoneDeleteCmd = &cobra.Command{
 	Short: "Delete a milestone",
 	Long:  "Delete an existing milestone.",
 	Example: `  # Delete by title
-  fj milestone delete "v1.0"
+  fgj milestone delete "v1.0"
 
   # Delete by ID
-  fj milestone delete 1
+  fgj milestone delete 1
 
   # Delete without confirmation
-  fj milestone delete "v1.0" -y`,
+  fgj milestone delete "v1.0" -y`,
 	Args: cobra.ExactArgs(1),
 	RunE: runMilestoneDelete,
 }
diff --git a/cmd/milestone_issues.go b/cmd/milestone_issues.go
new file mode 100644
index 0000000..ddde3ec
--- /dev/null
+++ b/cmd/milestone_issues.go
@@ -0,0 +1,164 @@
+package cmd
+
+import (
+	"fmt"
+
+	"code.gitea.io/sdk/gitea"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var milestoneIssuesCmd = &cobra.Command{
+	Use:     "issues",
+	Aliases: []string{"i"},
+	Short:   "Manage issues associated with a milestone",
+	Long:    "Associate or disassociate issues with a milestone.",
+}
+
+var milestoneIssuesAddCmd = &cobra.Command{
+	Use:   "add <title-or-id> <issue-number>...",
+	Short: "Add issues to a milestone",
+	Long:  "Associate one or more issues with a milestone.",
+	Example: `  # Add issues #5 and #7 to milestone "v1.0"
+  fgj milestone issues add "v1.0" 5 7
+
+  # Add issue #12 to milestone with ID 3 in a specific repo
+  fgj milestone issues add 3 12 -R owner/repo`,
+	Args: cobra.MinimumNArgs(2),
+	RunE: runMilestoneIssuesAdd,
+}
+
+var milestoneIssuesRemoveCmd = &cobra.Command{
+	Use:   "remove <title-or-id> <issue-number>...",
+	Short: "Remove issues from a milestone",
+	Long:  "Disassociate one or more issues from a milestone.",
+	Example: `  # Remove issues #5 and #7 from milestone "v1.0"
+  fgj milestone issues remove "v1.0" 5 7
+
+  # Remove issue #12 from milestone with ID 3 in a specific repo
+  fgj milestone issues remove 3 12 -R owner/repo`,
+	Args: cobra.MinimumNArgs(2),
+	RunE: runMilestoneIssuesRemove,
+}
+
+func init() {
+	milestoneCmd.AddCommand(milestoneIssuesCmd)
+	milestoneIssuesCmd.AddCommand(milestoneIssuesAddCmd)
+	milestoneIssuesCmd.AddCommand(milestoneIssuesRemoveCmd)
+
+	addRepoFlags(milestoneIssuesAddCmd)
+	addRepoFlags(milestoneIssuesRemoveCmd)
+}
+
+func runMilestoneIssuesAdd(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
+	}
+
+	milestoneID := ms.ID
+	cs := ios.ColorScheme()
+	hadError := false
+
+	for _, arg := range args[1:] {
+		issueNum, parseErr := parseIssueArg(arg)
+		if parseErr != nil {
+			fmt.Fprintf(ios.ErrOut, "invalid issue number %q: %v\n", arg, parseErr)
+			hadError = true
+			continue
+		}
+
+		_, _, editErr := client.EditIssue(owner, name, issueNum, gitea.EditIssueOption{
+			Milestone: &milestoneID,
+		})
+		if editErr != nil {
+			fmt.Fprintf(ios.ErrOut, "failed to add issue #%d to milestone %q: %v\n", issueNum, ms.Title, editErr)
+			hadError = true
+			continue
+		}
+
+		fmt.Fprintf(ios.Out, "%s Added issue #%d to milestone %q\n", cs.SuccessIcon(), issueNum, ms.Title)
+	}
+
+	if hadError {
+		return fmt.Errorf("one or more issues could not be added to milestone %q", ms.Title)
+	}
+	return nil
+}
+
+func runMilestoneIssuesRemove(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
+	}
+
+	cs := ios.ColorScheme()
+	hadError := false
+	var zero int64 = 0
+
+	for _, arg := range args[1:] {
+		issueNum, parseErr := parseIssueArg(arg)
+		if parseErr != nil {
+			fmt.Fprintf(ios.ErrOut, "invalid issue number %q: %v\n", arg, parseErr)
+			hadError = true
+			continue
+		}
+
+		// Setting Milestone to a pointer-to-zero clears the milestone association
+		// in Gitea's API (PATCH /repos/{owner}/{repo}/issues/{num} with {"milestone": 0}).
+		_, _, editErr := client.EditIssue(owner, name, issueNum, gitea.EditIssueOption{
+			Milestone: &zero,
+		})
+		if editErr != nil {
+			fmt.Fprintf(ios.ErrOut, "failed to remove issue #%d from milestone %q: %v\n", issueNum, ms.Title, editErr)
+			hadError = true
+			continue
+		}
+
+		fmt.Fprintf(ios.Out, "%s Removed issue #%d from milestone %q\n", cs.SuccessIcon(), issueNum, ms.Title)
+	}
+
+	if hadError {
+		return fmt.Errorf("one or more issues could not be removed from milestone %q", ms.Title)
+	}
+	return nil
+}
diff --git a/cmd/notification.go b/cmd/notification.go
new file mode 100644
index 0000000..bd245cf
--- /dev/null
+++ b/cmd/notification.go
@@ -0,0 +1,137 @@
+package cmd
+
+import (
+	"fmt"
+
+	"code.gitea.io/sdk/gitea"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var notificationCmd = &cobra.Command{
+	Use:     "notification",
+	Aliases: []string{"notifications", "n"},
+	Short:   "Manage user notifications",
+	Long:    "List and mark notifications for the authenticated user.",
+}
+
+var notificationListCmd = &cobra.Command{
+	Use:     "list",
+	Aliases: []string{"ls"},
+	Short:   "List notifications",
+	Long:    "List notifications for the authenticated user. Shows unread by default.",
+	Example: `  # List unread notifications
+  fgj notification list
+
+  # Include read and pinned notifications
+  fgj notification list --all
+
+  # Limit number of results
+  fgj notification list -L 50
+
+  # Output as JSON
+  fgj notification list --json`,
+	RunE: runNotificationList,
+}
+
+var notificationReadCmd = &cobra.Command{
+	Use:     "read <id>",
+	Aliases: []string{"r"},
+	Short:   "Mark a notification as read",
+	Long:    "Mark a single notification thread as read by its ID.",
+	Args:    cobra.ExactArgs(1),
+	RunE:    runNotificationRead,
+}
+
+func init() {
+	rootCmd.AddCommand(notificationCmd)
+	notificationCmd.AddCommand(notificationListCmd)
+	notificationCmd.AddCommand(notificationReadCmd)
+
+	notificationListCmd.Flags().Bool("all", false, "Include read and pinned notifications (not just unread)")
+	notificationListCmd.Flags().IntP("limit", "L", 30, "Maximum number of notifications to list")
+	addJSONFlags(notificationListCmd, "Output as JSON")
+}
+
+func runNotificationList(cmd *cobra.Command, args []string) error {
+	cfg, err := config.Load()
+	if err != nil {
+		return err
+	}
+
+	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	if err != nil {
+		return err
+	}
+
+	all, _ := cmd.Flags().GetBool("all")
+	limit, _ := cmd.Flags().GetInt("limit")
+	if limit <= 0 {
+		limit = 30
+	}
+
+	opt := gitea.ListNotificationOptions{
+		ListOptions: gitea.ListOptions{PageSize: limit},
+		Status:      []gitea.NotifyStatus{gitea.NotifyStatusUnread},
+	}
+	if all {
+		opt.Status = []gitea.NotifyStatus{gitea.NotifyStatusUnread, gitea.NotifyStatusRead, gitea.NotifyStatusPinned}
+	}
+
+	threads, _, err := client.ListNotifications(opt)
+	if err != nil {
+		return fmt.Errorf("failed to list notifications: %w", err)
+	}
+
+	if wantJSON(cmd) {
+		return outputJSON(cmd, threads)
+	}
+
+	if len(threads) == 0 {
+		fmt.Fprintln(ios.Out, "No notifications.")
+		return nil
+	}
+
+	tp := ios.NewTablePrinter()
+	tp.AddHeader("ID", "REPO", "TYPE", "STATE", "TITLE")
+	for _, t := range threads {
+		repo := ""
+		if t.Repository != nil {
+			repo = t.Repository.FullName
+		}
+		subjType, subjState, title := "", "", ""
+		if t.Subject != nil {
+			subjType = string(t.Subject.Type)
+			subjState = string(t.Subject.State)
+			title = t.Subject.Title
+		}
+		tp.AddRow(fmt.Sprintf("%d", t.ID), repo, subjType, subjState, title)
+	}
+	return tp.Render()
+}
+
+func runNotificationRead(cmd *cobra.Command, args []string) error {
+	id, err := parseIssueArg(args[0])
+	if err != nil {
+		return fmt.Errorf("invalid notification id %q: %w", args[0], err)
+	}
+
+	cfg, err := config.Load()
+	if err != nil {
+		return err
+	}
+
+	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	if err != nil {
+		return err
+	}
+
+	if _, _, err := client.ReadNotification(id, gitea.NotifyStatusRead); err != nil {
+		return fmt.Errorf("failed to mark notification %d as read: %w", id, err)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Marked notification %d as read\n", cs.SuccessIcon(), id)
+	return nil
+}
diff --git a/cmd/notification_states.go b/cmd/notification_states.go
new file mode 100644
index 0000000..438a22b
--- /dev/null
+++ b/cmd/notification_states.go
@@ -0,0 +1,60 @@
+package cmd
+
+import (
+	"fmt"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/spf13/cobra"
+)
+
+var notificationUnreadCmd = &cobra.Command{
+	Use:   "unread <id>",
+	Short: "Mark a notification as unread",
+	Long:  "Mark a single notification thread as unread by its ID.",
+	Args:  cobra.ExactArgs(1),
+	RunE:  runNotificationState(gitea.NotifyStatusUnread, "unread"),
+}
+
+var notificationPinCmd = &cobra.Command{
+	Use:   "pin <id>",
+	Short: "Pin a notification",
+	Long:  "Mark a single notification thread as pinned by its ID.",
+	Args:  cobra.ExactArgs(1),
+	RunE:  runNotificationState(gitea.NotifyStatusPinned, "pinned"),
+}
+
+var notificationUnpinCmd = &cobra.Command{
+	Use:   "unpin <id>",
+	Short: "Un-pin a notification",
+	Long:  "Un-pin a notification thread (marks it as read).",
+	Args:  cobra.ExactArgs(1),
+	RunE:  runNotificationState(gitea.NotifyStatusRead, "unpinned"),
+}
+
+func init() {
+	notificationCmd.AddCommand(notificationUnreadCmd)
+	notificationCmd.AddCommand(notificationPinCmd)
+	notificationCmd.AddCommand(notificationUnpinCmd)
+}
+
+func runNotificationState(status gitea.NotifyStatus, verb string) func(*cobra.Command, []string) error {
+	return func(cmd *cobra.Command, args []string) error {
+		id, err := parseIssueArg(args[0])
+		if err != nil {
+			return fmt.Errorf("invalid notification id %q: %w", args[0], err)
+		}
+
+		client, err := loadClient()
+		if err != nil {
+			return err
+		}
+
+		if _, _, err := client.ReadNotification(id, status); err != nil {
+			return fmt.Errorf("failed to mark notification %d as %s: %w", id, verb, err)
+		}
+
+		cs := ios.ColorScheme()
+		fmt.Fprintf(ios.Out, "%s Marked notification %d as %s\n", cs.SuccessIcon(), id, verb)
+		return nil
+	}
+}
diff --git a/cmd/open.go b/cmd/open.go
new file mode 100644
index 0000000..cde0a06
--- /dev/null
+++ b/cmd/open.go
@@ -0,0 +1,104 @@
+package cmd
+
+import (
+	"fmt"
+	"os/exec"
+	"runtime"
+
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var openCmd = &cobra.Command{
+	Use:     "open [issue-or-pr-number]",
+	Aliases: []string{"o"},
+	Short:   "Open a repository, issue, or pull request in a browser",
+	Long: `Open the repository page in a web browser. When an issue or pull request
+number is given, that page is opened instead.
+
+Repository is auto-detected from the current git context, or specified with -R.`,
+	Example: `  # Open the current repository
+  fgj open
+
+  # Open a specific repository
+  fgj open -R owner/repo
+
+  # Open issue or PR #42 (Forgejo routes both via the same number)
+  fgj open 42
+  fgj open '#42'
+
+  # Print the URL instead of launching a browser
+  fgj open 42 --url`,
+	Args: cobra.MaximumNArgs(1),
+	RunE: runOpen,
+}
+
+func init() {
+	rootCmd.AddCommand(openCmd)
+	addRepoFlags(openCmd)
+	openCmd.Flags().Bool("url", false, "Print URL instead of opening a browser")
+}
+
+func runOpen(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
+	}
+
+	url := fmt.Sprintf("https://%s/%s/%s", client.Hostname(), owner, name)
+
+	if len(args) == 1 {
+		num, err := parseIssueArg(args[0])
+		if err != nil {
+			return fmt.Errorf("invalid issue or PR number %q: %w", args[0], err)
+		}
+		issue, _, err := client.GetIssue(owner, name, num)
+		if err != nil {
+			return fmt.Errorf("failed to look up #%d: %w", num, err)
+		}
+		kind := "issues"
+		if issue.PullRequest != nil {
+			kind = "pulls"
+		}
+		url = fmt.Sprintf("https://%s/%s/%s/%s/%d", client.Hostname(), owner, name, kind, num)
+	}
+
+	printOnly, _ := cmd.Flags().GetBool("url")
+	if printOnly || !ios.IsStdoutTTY() {
+		fmt.Fprintln(ios.Out, url)
+		return nil
+	}
+
+	if err := launchBrowser(url); err != nil {
+		fmt.Fprintf(ios.ErrOut, "Could not open browser (%v); URL: %s\n", err, url)
+		return nil
+	}
+	fmt.Fprintf(ios.ErrOut, "Opening %s in your browser.\n", url)
+	return nil
+}
+
+// launchBrowser opens url in the OS default browser.
+func launchBrowser(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:
+		cmd = exec.Command("xdg-open", url)
+	}
+	return cmd.Start()
+}
diff --git a/cmd/org.go b/cmd/org.go
new file mode 100644
index 0000000..8e11804
--- /dev/null
+++ b/cmd/org.go
@@ -0,0 +1,186 @@
+package cmd
+
+import (
+	"fmt"
+
+	"code.gitea.io/sdk/gitea"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var orgCmd = &cobra.Command{
+	Use:     "org",
+	Aliases: []string{"organization", "organizations"},
+	Short:   "Manage organizations",
+	Long:    "List, create, and delete organizations on the current host.",
+}
+
+var orgListCmd = &cobra.Command{
+	Use:     "list",
+	Aliases: []string{"ls"},
+	Short:   "List organizations",
+	Long:    "List organizations the authenticated user is a member of.",
+	Example: `  # List your organizations
+  fgj org list
+
+  # Output as JSON
+  fgj org list --json`,
+	RunE: runOrgList,
+}
+
+var orgCreateCmd = &cobra.Command{
+	Use:   "create <name>",
+	Short: "Create an organization",
+	Long:  "Create a new organization. You become the initial owner.",
+	Example: `  # Create an organization
+  fgj org create my-org
+
+  # Create with description and visibility
+  fgj org create my-org --description "Internal tooling" --visibility private`,
+	Args: cobra.ExactArgs(1),
+	RunE: runOrgCreate,
+}
+
+var orgDeleteCmd = &cobra.Command{
+	Use:     "delete <name>",
+	Aliases: []string{"rm"},
+	Short:   "Delete an organization",
+	Long:    "Delete an organization. This is irreversible and removes all the organization's repositories.",
+	Args:    cobra.ExactArgs(1),
+	RunE:    runOrgDelete,
+}
+
+func init() {
+	rootCmd.AddCommand(orgCmd)
+	orgCmd.AddCommand(orgListCmd)
+	orgCmd.AddCommand(orgCreateCmd)
+	orgCmd.AddCommand(orgDeleteCmd)
+
+	orgListCmd.Flags().IntP("limit", "L", 50, "Maximum number of organizations to list")
+	addJSONFlags(orgListCmd, "Output as JSON")
+
+	orgCreateCmd.Flags().String("description", "", "Organization description")
+	orgCreateCmd.Flags().String("full-name", "", "Full display name")
+	orgCreateCmd.Flags().String("website", "", "Website URL")
+	orgCreateCmd.Flags().String("location", "", "Location")
+	orgCreateCmd.Flags().String("visibility", "public", "Visibility: public, limited, or private")
+
+	orgDeleteCmd.Flags().BoolP("yes", "y", false, "Skip confirmation prompt")
+}
+
+func runOrgList(cmd *cobra.Command, args []string) error {
+	client, err := loadClient()
+	if err != nil {
+		return err
+	}
+
+	limit, _ := cmd.Flags().GetInt("limit")
+	if limit <= 0 {
+		limit = 50
+	}
+
+	orgs, _, err := client.ListMyOrgs(gitea.ListOrgsOptions{
+		ListOptions: gitea.ListOptions{PageSize: limit},
+	})
+	if err != nil {
+		return fmt.Errorf("failed to list organizations: %w", err)
+	}
+
+	if wantJSON(cmd) {
+		return outputJSON(cmd, orgs)
+	}
+
+	if len(orgs) == 0 {
+		fmt.Fprintln(ios.Out, "No organizations found.")
+		return nil
+	}
+
+	tp := ios.NewTablePrinter()
+	tp.AddHeader("NAME", "FULL NAME", "VISIBILITY", "DESCRIPTION")
+	for _, o := range orgs {
+		tp.AddRow(o.UserName, o.FullName, string(o.Visibility), o.Description)
+	}
+	return tp.Render()
+}
+
+func runOrgCreate(cmd *cobra.Command, args []string) error {
+	client, err := loadClient()
+	if err != nil {
+		return err
+	}
+
+	name := args[0]
+	desc, _ := cmd.Flags().GetString("description")
+	fullName, _ := cmd.Flags().GetString("full-name")
+	website, _ := cmd.Flags().GetString("website")
+	location, _ := cmd.Flags().GetString("location")
+	visStr, _ := cmd.Flags().GetString("visibility")
+
+	var vis gitea.VisibleType
+	switch visStr {
+	case "public", "":
+		vis = gitea.VisibleTypePublic
+	case "limited":
+		vis = gitea.VisibleTypeLimited
+	case "private":
+		vis = gitea.VisibleTypePrivate
+	default:
+		return fmt.Errorf("invalid visibility %q (must be public, limited, or private)", visStr)
+	}
+
+	org, _, err := client.CreateOrg(gitea.CreateOrgOption{
+		Name:        name,
+		FullName:    fullName,
+		Description: desc,
+		Website:     website,
+		Location:    location,
+		Visibility:  vis,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to create organization %q: %w", name, err)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Created organization %q\n", cs.SuccessIcon(), org.UserName)
+	return nil
+}
+
+func runOrgDelete(cmd *cobra.Command, args []string) error {
+	client, err := loadClient()
+	if err != nil {
+		return err
+	}
+
+	name := args[0]
+	skipConfirm, _ := cmd.Flags().GetBool("yes")
+
+	if !skipConfirm && ios.IsStdinTTY() {
+		answer, err := promptLine(fmt.Sprintf("Delete organization %q? This is irreversible and deletes all repositories. [y/N]: ", name))
+		if err != nil {
+			return err
+		}
+		if answer != "y" && answer != "Y" && answer != "yes" {
+			fmt.Fprintln(ios.ErrOut, "Cancelled.")
+			return nil
+		}
+	}
+
+	if _, err := client.DeleteOrg(name); err != nil {
+		return fmt.Errorf("failed to delete organization %q: %w", name, err)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Deleted organization %q\n", cs.SuccessIcon(), name)
+	return nil
+}
+
+// loadClient constructs an api.Client from config without requiring a repo context.
+// Use this for commands that operate on the host itself (orgs, notifications, user).
+func loadClient() (*api.Client, error) {
+	cfg, err := config.Load()
+	if err != nil {
+		return nil, err
+	}
+	return api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+}
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..d3137c2 100644
--- a/cmd/pr.go
+++ b/cmd/pr.go
@@ -4,16 +4,66 @@ import (
 	"fmt"
 	"net/http"
 	"os/exec"
+	"strconv"
 	"strings"
+	"time"
 
 	"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"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	gitpkg "forgejo.zerova.net/public/fgj-sid/internal/git"
+	"forgejo.zerova.net/public/fgj-sid/internal/text"
 	"github.com/spf13/cobra"
 )
 
+// parseDateArg parses a --since / --before argument.
+// Accepted forms: "2006-01-02", RFC 3339, "2006-01-02 15:04:05" (local),
+// or a relative delta like "7d", "24h", "2w", "1m" (months treated as 30 days).
+func parseDateArg(s string) (time.Time, error) {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return time.Time{}, fmt.Errorf("empty date")
+	}
+
+	// Relative delta: <N><unit>
+	if last := s[len(s)-1]; last == 'h' || last == 'd' || last == 'w' || last == 'm' {
+		numPart := s[:len(s)-1]
+		if n, err := strconv.Atoi(numPart); err == nil && n >= 0 {
+			var d time.Duration
+			switch last {
+			case 'h':
+				d = time.Duration(n) * time.Hour
+			case 'd':
+				d = time.Duration(n) * 24 * time.Hour
+			case 'w':
+				d = time.Duration(n) * 7 * 24 * time.Hour
+			case 'm':
+				// Months treated as 30 days (crude but documented).
+				d = time.Duration(n) * 30 * 24 * time.Hour
+			}
+			return time.Now().Add(-d), nil
+		}
+	}
+
+	layouts := []string{
+		"2006-01-02",
+		time.RFC3339,
+		"2006-01-02 15:04:05",
+	}
+	for _, layout := range layouts {
+		if layout == "2006-01-02" || layout == "2006-01-02 15:04:05" {
+			if t, err := time.ParseInLocation(layout, s, time.Local); err == nil {
+				return t, nil
+			}
+		} else {
+			if t, err := time.Parse(layout, s); err == nil {
+				return t, nil
+			}
+		}
+	}
+	return time.Time{}, fmt.Errorf("unrecognized date format: %q (expected YYYY-MM-DD, RFC 3339, 'YYYY-MM-DD HH:MM:SS', or a relative delta like 7d/24h/2w/1m)", s)
+}
+
 var prCmd = &cobra.Command{
 	Use:     "pr",
 	Aliases: []string{"pull-request"},
@@ -26,13 +76,19 @@ var prListCmd = &cobra.Command{
 	Short: "List pull requests",
 	Long:  "List pull requests in a repository.",
 	Example: `  # List open pull requests
-  fj pr list
+  fgj pr list
 
   # List all pull requests for a specific repo
-  fj pr list -s all -R owner/repo
+  fgj pr list -s all -R owner/repo
 
   # Output as JSON
-  fj pr list --json`,
+  fgj pr list --json
+
+  # PRs updated in the last 7 days
+  fgj pr list --since 7d
+
+  # Issues touched between two dates
+  fgj issue list --since 2026-04-01 --before 2026-04-15`,
 	RunE: runPRList,
 }
 
@@ -41,19 +97,19 @@ var prViewCmd = &cobra.Command{
 	Short: "View a pull request",
 	Long:  "Display detailed information about a pull request.",
 	Example: `  # View pull request #5
-  fj pr view 5
+  fgj pr view 5
 
   # View using URL
-  fj pr view https://codeberg.org/owner/repo/pulls/5
+  fgj pr view https://codeberg.org/owner/repo/pulls/5
 
   # View PR for current branch
-  fj pr view
+  fgj pr view
 
   # Open in browser
-  fj pr view 5 --web
+  fgj pr view 5 --web
 
   # View as JSON
-  fj pr view 5 --json`,
+  fgj pr view 5 --json`,
 	Args: cobra.MaximumNArgs(1),
 	RunE: runPRView,
 }
@@ -63,13 +119,13 @@ var prCreateCmd = &cobra.Command{
 	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
+  fgj 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
+  fgj 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`,
+  fgj pr create -t "Update docs" -H docs/update -a @me`,
 	RunE: runPRCreate,
 }
 
@@ -78,16 +134,16 @@ var prMergeCmd = &cobra.Command{
 	Short: "Merge a pull request",
 	Long:  "Merge a pull request.",
 	Example: `  # Merge pull request #5
-  fj pr merge 5
+  fgj pr merge 5
 
   # Squash merge
-  fj pr merge 5 --merge-method squash
+  fgj pr merge 5 --merge-method squash
 
   # Rebase merge
-  fj pr merge 5 --merge-method rebase
+  fgj pr merge 5 --merge-method rebase
 
   # Merge without confirmation
-  fj pr merge 5 -y`,
+  fgj pr merge 5 -y`,
 	Args: cobra.ExactArgs(1),
 	RunE: runPRMerge,
 }
@@ -97,10 +153,10 @@ var prCloseCmd = &cobra.Command{
 	Short: "Close a pull request",
 	Long:  "Close a pull request without merging.",
 	Example: `  # Close PR #5
-  fj pr close 5
+  fgj pr close 5
 
   # Close with a comment
-  fj pr close 5 -c "Won't merge, superseded by #10"`,
+  fgj pr close 5 -c "Won't merge, superseded by #10"`,
 	Args: cobra.ExactArgs(1),
 	RunE: runPRClose,
 }
@@ -110,7 +166,7 @@ var prReopenCmd = &cobra.Command{
 	Short: "Reopen a pull request",
 	Long:  "Reopen a closed pull request.",
 	Example: `  # Reopen PR #5
-  fj pr reopen 5`,
+  fgj pr reopen 5`,
 	Args: cobra.ExactArgs(1),
 	RunE: runPRReopen,
 }
@@ -120,13 +176,13 @@ var prEditCmd = &cobra.Command{
 	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"
+  fgj pr edit 5 -t "Updated title"
 
   # Add assignees and labels
-  fj pr edit 5 --add-assignee user1 --add-label bug
+  fgj 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"`,
+  fgj pr edit 5 --remove-reviewer user2 --milestone "v1.0"`,
 	Args: cobra.ExactArgs(1),
 	RunE: runPREdit,
 }
@@ -136,7 +192,7 @@ var prCheckoutCmd = &cobra.Command{
 	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`,
+  fgj pr checkout 5`,
 	Args: cobra.ExactArgs(1),
 	RunE: runPRCheckout,
 }
@@ -167,6 +223,8 @@ func init() {
 	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().String("since", "", "Only items updated at or after this date (YYYY-MM-DD, RFC 3339, or relative like 7d)")
+	prListCmd.Flags().String("before", "", "Only items updated strictly before this date (YYYY-MM-DD, RFC 3339, or relative like 1d)")
 	prListCmd.Flags().BoolP("web", "w", false, "Open list in web browser")
 	addJSONFlags(prListCmd, "Output pull requests as JSON")
 
@@ -217,6 +275,27 @@ func runPRList(cmd *cobra.Command, args []string) error {
 	draft, _ := cmd.Flags().GetBool("draft")
 	head, _ := cmd.Flags().GetString("head")
 	base, _ := cmd.Flags().GetString("base")
+	sinceStr, _ := cmd.Flags().GetString("since")
+	beforeStr, _ := cmd.Flags().GetString("before")
+
+	var sinceTime, beforeTime time.Time
+	var hasSince, hasBefore bool
+	if sinceStr != "" {
+		t, err := parseDateArg(sinceStr)
+		if err != nil {
+			return fmt.Errorf("invalid --since: %w", err)
+		}
+		sinceTime = t
+		hasSince = true
+	}
+	if beforeStr != "" {
+		t, err := parseDateArg(beforeStr)
+		if err != nil {
+			return fmt.Errorf("invalid --before: %w", err)
+		}
+		beforeTime = t
+		hasBefore = true
+	}
 
 	owner, name, err := parseRepo(repo)
 	if err != nil {
@@ -249,35 +328,46 @@ 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 != ""
+	// server-side since/before unsupported for pulls; filtering client-side
+	needsClientFilter := assignee != "" || author != "" || len(labels) > 0 || search != "" || draft || head != "" || base != "" || hasSince || hasBefore
 
 	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]
+		page := 1
+		for {
+			batch, _, err := client.ListRepoPullRequests(owner, name, gitea.ListPullRequestsOptions{
+				State:       stateType,
+				ListOptions: gitea.ListOptions{Page: page, PageSize: 50},
+			})
+			if err != nil {
+				ios.StopSpinner()
+				return fmt.Errorf("failed to list pull requests: %w", err)
 			}
+			prs = append(prs, batch...)
+			if len(batch) < 50 {
+				break
+			}
+			page++
+		}
+		prs = filterPRs(prs, author, assignee, labels, search, draft, head, base)
+		if hasSince || hasBefore {
+			prs = filterPRsByDate(prs, sinceTime, hasSince, beforeTime, hasBefore)
+		}
+		if len(prs) > limit {
+			prs = prs[:limit]
 		}
 	} else {
-		prs, err = paginateGitea(limit, fetchPage)
+		prs, _, err = client.ListRepoPullRequests(owner, name, gitea.ListPullRequestsOptions{
+			State:       stateType,
+			ListOptions: gitea.ListOptions{PageSize: limit},
+		})
+		if err != nil {
+			ios.StopSpinner()
+			return fmt.Errorf("failed to list pull requests: %w", err)
+		}
 	}
 	ios.StopSpinner()
-	if err != nil {
-		return fmt.Errorf("failed to list pull requests: %w", err)
-	}
 
 	if wantJSON(cmd) {
 		return outputJSON(cmd, prs)
@@ -347,6 +437,27 @@ func filterPRs(prs []*gitea.PullRequest, author, assignee string, labels []strin
 	return result
 }
 
+// filterPRsByDate applies the --since / --before range against pr.Updated.
+func filterPRsByDate(prs []*gitea.PullRequest, since time.Time, hasSince bool, before time.Time, hasBefore bool) []*gitea.PullRequest {
+	if !hasSince && !hasBefore {
+		return prs
+	}
+	result := make([]*gitea.PullRequest, 0, len(prs))
+	for _, pr := range prs {
+		if pr.Updated == nil {
+			continue
+		}
+		if hasSince && pr.Updated.Before(since) {
+			continue
+		}
+		if hasBefore && !pr.Updated.Before(before) {
+			continue
+		}
+		result = append(result, pr)
+	}
+	return result
+}
+
 func runPRView(cmd *cobra.Command, args []string) error {
 	repo, _ := cmd.Flags().GetString("repo")
 
diff --git a/cmd/pr_approve_reject.go b/cmd/pr_approve_reject.go
new file mode 100644
index 0000000..b394c16
--- /dev/null
+++ b/cmd/pr_approve_reject.go
@@ -0,0 +1,102 @@
+package cmd
+
+import (
+	"fmt"
+
+	"code.gitea.io/sdk/gitea"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var prApproveCmd = &cobra.Command{
+	Use:     "approve <number>",
+	Aliases: []string{"lgtm"},
+	Short:   "Approve a pull request",
+	Long:    "Shortcut for 'fgj pr review <n> --approve'. Body is optional.",
+	Example: `  # Approve with no body
+  fgj pr approve 42
+
+  # Approve with a message
+  fgj pr approve 42 -b "Thanks, shipping."`,
+	Args: cobra.ExactArgs(1),
+	RunE: runPRApproveReject(gitea.ReviewStateApproved, "approved", false),
+}
+
+var prRejectCmd = &cobra.Command{
+	Use:   "reject <number>",
+	Short: "Request changes on a pull request",
+	Long:  "Shortcut for 'fgj pr review <n> --request-changes'. Body is required.",
+	Example: `  # Reject with explanation
+  fgj pr reject 42 -b "See the inline comments on auth.go"
+
+  # Reject with a longer message from a file
+  fgj pr reject 42 --body-file feedback.md`,
+	Args: cobra.ExactArgs(1),
+	RunE: runPRApproveReject(gitea.ReviewStateRequestChanges, "reviewed with requested changes", true),
+}
+
+func init() {
+	prCmd.AddCommand(prApproveCmd)
+	prCmd.AddCommand(prRejectCmd)
+
+	for _, c := range []*cobra.Command{prApproveCmd, prRejectCmd} {
+		c.Flags().StringP("repo", "R", "", "Repository in owner/name format")
+		c.Flags().StringP("body", "b", "", "Review body/message")
+		c.Flags().String("body-file", "", "Read body from file (use \"-\" for stdin)")
+		addJSONFlags(c, "Output created review as JSON")
+	}
+}
+
+func runPRApproveReject(state gitea.ReviewStateType, verb string, requireBody bool) func(cmd *cobra.Command, args []string) error {
+	return func(cmd *cobra.Command, args []string) error {
+		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 requireBody && body == "" {
+			return fmt.Errorf("a body is required (use --body or --body-file)")
+		}
+
+		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("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 submit 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, verb)
+		if review.HTMLURL != "" {
+			fmt.Fprintf(ios.Out, "View at: %s\n", review.HTMLURL)
+		}
+		return nil
+	}
+}
diff --git a/cmd/pr_checks.go b/cmd/pr_checks.go
index fdcf446..f475524 100644
--- a/cmd/pr_checks.go
+++ b/cmd/pr_checks.go
@@ -4,9 +4,9 @@ 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"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"forgejo.zerova.net/public/fgj-sid/internal/iostreams"
 	"github.com/spf13/cobra"
 )
 
@@ -15,10 +15,10 @@ var prChecksCmd = &cobra.Command{
 	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
+  fgj pr checks 5
 
   # Output as JSON
-  fj pr checks 5 --json`,
+  fgj pr checks 5 --json`,
 	Args: cobra.ExactArgs(1),
 	RunE: runPRChecks,
 }
diff --git a/cmd/pr_clean.go b/cmd/pr_clean.go
new file mode 100644
index 0000000..3b678c0
--- /dev/null
+++ b/cmd/pr_clean.go
@@ -0,0 +1,98 @@
+package cmd
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"forgejo.zerova.net/public/fgj-sid/internal/git"
+	"github.com/spf13/cobra"
+)
+
+var prCleanCmd = &cobra.Command{
+	Use:   "clean <number>",
+	Short: "Delete the local branch created by 'pr checkout'",
+	Long: `Remove the local branch that was checked out for a pull request.
+
+For safety, the PR must be closed (merged or declined). If the branch is
+currently checked out, switch away first — this command refuses to delete
+your active branch.
+
+Pass --force to delete the local branch even if the PR is still open.`,
+	Example: `  # Clean up after a merged PR
+  fgj pr clean 42
+
+  # Force-delete local branch for an open PR
+  fgj pr clean 42 --force`,
+	Args: cobra.ExactArgs(1),
+	RunE: runPRClean,
+}
+
+func init() {
+	prCmd.AddCommand(prCleanCmd)
+	addRepoFlags(prCleanCmd)
+	prCleanCmd.Flags().Bool("force", false, "Delete the local branch even if the PR is still open")
+}
+
+func runPRClean(cmd *cobra.Command, args []string) error {
+	prNumber, err := parseIssueArg(args[0])
+	if err != nil {
+		return fmt.Errorf("invalid pull request number: %w", err)
+	}
+
+	repoFlag, _ := cmd.Flags().GetString("repo")
+	owner, name, err := parseRepo(repoFlag)
+	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
+	}
+
+	force, _ := cmd.Flags().GetBool("force")
+
+	pr, _, err := client.GetPullRequest(owner, name, prNumber)
+	if err != nil {
+		return fmt.Errorf("failed to get pull request: %w", err)
+	}
+
+	if !force && string(pr.State) == "open" {
+		return fmt.Errorf("PR #%d is still open; refuse to delete local branch without --force", prNumber)
+	}
+
+	headBranch := pr.Head.Ref
+	if headBranch == "" {
+		return fmt.Errorf("PR #%d has no head branch to clean (it may have been deleted already)", prNumber)
+	}
+
+	// Refuse to delete the current branch.
+	current, err := git.GetCurrentBranch()
+	if err == nil && current == headBranch {
+		return fmt.Errorf("branch %q is currently checked out; switch to another branch first (e.g. 'git switch main')", headBranch)
+	}
+
+	// Check local branch exists.
+	if out, _ := exec.Command("git", "rev-parse", "--verify", "--quiet", "refs/heads/"+headBranch).Output(); len(strings.TrimSpace(string(out))) == 0 {
+		fmt.Fprintf(ios.ErrOut, "Local branch %q not found; nothing to clean.\n", headBranch)
+		return nil
+	}
+
+	delCmd := exec.Command("git", "branch", "-D", headBranch)
+	delCmd.Stdout = ios.Out
+	delCmd.Stderr = ios.ErrOut
+	if err := delCmd.Run(); err != nil {
+		return fmt.Errorf("failed to delete local branch %q: %w", headBranch, err)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Deleted local branch %q\n", cs.SuccessIcon(), headBranch)
+	return nil
+}
diff --git a/cmd/pr_diff.go b/cmd/pr_diff.go
index 18b4b2c..414669f 100644
--- a/cmd/pr_diff.go
+++ b/cmd/pr_diff.go
@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"strings"
 
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
 	"github.com/spf13/cobra"
 )
 
@@ -14,16 +14,16 @@ var prDiffCmd = &cobra.Command{
 	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
+  fgj pr diff 123
 
   # Colorized diff output
-  fj pr diff 123 --color always
+  fgj pr diff 123 --color always
 
   # Show only changed file names
-  fj pr diff 123 --name-only
+  fgj pr diff 123 --name-only
 
   # Show diffstat summary
-  fj pr diff 123 --stat`,
+  fgj pr diff 123 --stat`,
 	Args: cobra.ExactArgs(1),
 	RunE: runPRDiff,
 }
diff --git a/cmd/pr_review.go b/cmd/pr_review.go
index 87a1314..94115ff 100644
--- a/cmd/pr_review.go
+++ b/cmd/pr_review.go
@@ -6,8 +6,8 @@ import (
 	"os"
 
 	"code.gitea.io/sdk/gitea"
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
 	"github.com/spf13/cobra"
 )
 
@@ -16,16 +16,16 @@ var prCommentCmd = &cobra.Command{
 	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!"
+  fgj pr comment 123 -b "Looks good!"
 
   # Comment from a file
-  fj pr comment 123 --body-file review-notes.md
+  fgj pr comment 123 --body-file review-notes.md
 
   # Comment from stdin
-  echo "LGTM" | fj pr comment 123 --body-file -
+  echo "LGTM" | fgj pr comment 123 --body-file -
 
   # Output as JSON
-  fj pr comment 123 -b "Nice work" --json`,
+  fgj pr comment 123 -b "Nice work" --json`,
 	Args: cobra.ExactArgs(1),
 	RunE: runPRComment,
 }
@@ -35,16 +35,16 @@ var prReviewCmd = &cobra.Command{
 	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"
+  fgj pr review 123 --approve -b "LGTM"
 
   # Request changes
-  fj pr review 123 --request-changes -b "Please fix the error handling"
+  fgj pr review 123 --request-changes -b "Please fix the error handling"
 
   # Submit a review comment
-  fj pr review 123 --comment -b "Some observations"
+  fgj pr review 123 --comment -b "Some observations"
 
   # Request changes with body from file
-  fj pr review 123 --request-changes --body-file feedback.md`,
+  fgj pr review 123 --request-changes --body-file feedback.md`,
 	Args: cobra.ExactArgs(1),
 	RunE: runPRReview,
 }
diff --git a/cmd/pr_review_comments.go b/cmd/pr_review_comments.go
new file mode 100644
index 0000000..c577d59
--- /dev/null
+++ b/cmd/pr_review_comments.go
@@ -0,0 +1,171 @@
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	"code.gitea.io/sdk/gitea"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var prReviewCommentsCmd = &cobra.Command{
+	Use:     "review-comments <number>",
+	Aliases: []string{"rc"},
+	Short:   "List review comments on a pull request",
+	Long:    "List all review comments (inline code comments) across every review on a PR.",
+	Example: `  # List review comments on PR #42
+  fgj pr review-comments 42
+
+  # As JSON
+  fgj pr review-comments 42 --json`,
+	Args: cobra.ExactArgs(1),
+	RunE: runPRReviewComments,
+}
+
+var prResolveCmd = &cobra.Command{
+	Use:   "resolve <comment-id>",
+	Short: "Resolve a PR review comment",
+	Long: `Mark a pull request review comment as resolved. Comment IDs are shown
+in the output of 'fgj pr review-comments'.
+
+Requires Forgejo 8.x+ / Gitea 1.22+.`,
+	Args: cobra.ExactArgs(1),
+	RunE: runPRResolveComment(true),
+}
+
+var prUnresolveCmd = &cobra.Command{
+	Use:   "unresolve <comment-id>",
+	Short: "Unresolve a PR review comment",
+	Long:  "Reopen a previously-resolved pull request review comment.",
+	Args:  cobra.ExactArgs(1),
+	RunE:  runPRResolveComment(false),
+}
+
+func init() {
+	prCmd.AddCommand(prReviewCommentsCmd)
+	prCmd.AddCommand(prResolveCmd)
+	prCmd.AddCommand(prUnresolveCmd)
+
+	addRepoFlags(prReviewCommentsCmd)
+	addJSONFlags(prReviewCommentsCmd, "Output as JSON")
+
+	addRepoFlags(prResolveCmd)
+	addRepoFlags(prUnresolveCmd)
+}
+
+func runPRReviewComments(cmd *cobra.Command, args []string) error {
+	prNumber, err := parseIssueArg(args[0])
+	if err != nil {
+		return fmt.Errorf("invalid pull request number: %w", err)
+	}
+
+	client, owner, name, err := newPRCommentClient(cmd)
+	if err != nil {
+		return err
+	}
+
+	reviews, _, err := client.ListPullReviews(owner, name, prNumber, gitea.ListPullReviewsOptions{})
+	if err != nil {
+		return fmt.Errorf("failed to list reviews: %w", err)
+	}
+
+	var all []*gitea.PullReviewComment
+	for _, r := range reviews {
+		comments, _, err := client.ListPullReviewComments(owner, name, prNumber, r.ID)
+		if err != nil {
+			return fmt.Errorf("failed to list comments for review %d: %w", r.ID, err)
+		}
+		all = append(all, comments...)
+	}
+
+	if wantJSON(cmd) {
+		return outputJSON(cmd, all)
+	}
+
+	if len(all) == 0 {
+		fmt.Fprintln(ios.Out, "No review comments on this PR.")
+		return nil
+	}
+
+	tp := ios.NewTablePrinter()
+	tp.AddHeader("ID", "REVIEWER", "PATH", "LINE", "RESOLVED", "BODY")
+	for _, c := range all {
+		reviewer := ""
+		if c.Reviewer != nil {
+			reviewer = c.Reviewer.UserName
+		}
+		resolved := ""
+		if c.Resolver != nil {
+			resolved = "yes"
+		}
+		// Collapse multi-line bodies for table view.
+		body := strings.ReplaceAll(c.Body, "\n", " ")
+		if len(body) > 80 {
+			body = body[:77] + "..."
+		}
+		tp.AddRow(
+			fmt.Sprintf("%d", c.ID),
+			reviewer,
+			c.Path,
+			fmt.Sprintf("%d", c.LineNum),
+			resolved,
+			body,
+		)
+	}
+	return tp.Render()
+}
+
+// runPRResolveComment returns a RunE closure that either resolves or unresolves
+// a review comment, depending on the `resolve` flag. The underlying SDK
+// (v0.22.1) doesn't expose these endpoints yet, so we call them raw.
+func runPRResolveComment(resolve bool) func(cmd *cobra.Command, args []string) error {
+	return func(cmd *cobra.Command, args []string) error {
+		id, err := parseIssueArg(args[0])
+		if err != nil {
+			return fmt.Errorf("invalid comment id: %w", err)
+		}
+
+		client, owner, name, err := newPRCommentClient(cmd)
+		if err != nil {
+			return err
+		}
+
+		path := fmt.Sprintf("/api/v1/repos/%s/%s/pulls/comments/%d", owner, name, id)
+		action := "unresolve"
+		if resolve {
+			action = "resolve"
+		}
+		endpoint := path + "/" + action
+
+		if err := client.PostJSON(endpoint, map[string]any{}, nil); err != nil {
+			return fmt.Errorf("failed to %s comment %d: %w", action, id, err)
+		}
+
+		cs := ios.ColorScheme()
+		verb := "Resolved"
+		if !resolve {
+			verb = "Unresolved"
+		}
+		fmt.Fprintf(ios.Out, "%s %s comment %d\n", cs.SuccessIcon(), verb, id)
+		return nil
+	}
+}
+
+func newPRCommentClient(cmd *cobra.Command) (*api.Client, string, string, error) {
+	repoFlag, _ := cmd.Flags().GetString("repo")
+	owner, name, err := parseRepo(repoFlag)
+	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
+}
diff --git a/cmd/release.go b/cmd/release.go
index 79f298e..b83dcd8 100644
--- a/cmd/release.go
+++ b/cmd/release.go
@@ -9,9 +9,9 @@ import (
 	"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"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"forgejo.zerova.net/public/fgj-sid/internal/text"
 	"github.com/spf13/cobra"
 )
 
@@ -27,13 +27,13 @@ var releaseListCmd = &cobra.Command{
 	Short: "List releases",
 	Long:  "List releases in a repository.",
 	Example: `  # List releases
-  fj release list
+  fgj release list
 
   # List only draft releases
-  fj release list --draft
+  fgj release list --draft
 
   # Output as JSON with a custom limit
-  fj release list --json --limit 10`,
+  fgj release list --json --limit 10`,
 	RunE: runReleaseList,
 }
 
@@ -42,16 +42,16 @@ var releaseViewCmd = &cobra.Command{
 	Short: "View a release",
 	Long:  "Display detailed information about a release.",
 	Example: `  # View a release by tag
-  fj release view v1.0.0
+  fgj release view v1.0.0
 
   # View the latest release
-  fj release view latest
+  fgj release view latest
 
   # Open in browser
-  fj release view v1.0.0 --web
+  fgj release view v1.0.0 --web
 
   # Output as JSON
-  fj release view v1.0.0 --json`,
+  fgj release view v1.0.0 --json`,
 	Args: cobra.ExactArgs(1),
 	RunE: runReleaseView,
 }
@@ -61,16 +61,16 @@ var releaseCreateCmd = &cobra.Command{
 	Short: "Create a release",
 	Long:  "Create a new release and optionally upload assets.",
 	Example: `  # Create a release
-  fj release create v1.0.0
+  fgj 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"
+  fgj 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
+  fgj 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`,
+  fgj release create v1.0.0 -F CHANGELOG.md`,
 	Args: cobra.MinimumNArgs(1),
 	RunE: runReleaseCreate,
 }
@@ -80,10 +80,10 @@ var releaseUploadCmd = &cobra.Command{
 	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
+  fgj 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`,
+  fgj release upload latest build/output.zip --clobber`,
 	Args: cobra.MinimumNArgs(2),
 	RunE: runReleaseUpload,
 }
@@ -93,13 +93,13 @@ var releaseDownloadCmd = &cobra.Command{
 	Short: "Download release assets",
 	Long:  "Download assets from a release.",
 	Example: `  # Download all assets from a release
-  fj release download v1.0.0
+  fgj release download v1.0.0
 
   # Download to a specific directory
-  fj release download v1.0.0 -D ./downloads
+  fgj release download v1.0.0 -D ./downloads
 
   # Download a specific asset by name pattern
-  fj release download v1.0.0 -p "*.tar.gz"`,
+  fgj release download v1.0.0 -p "*.tar.gz"`,
 	Args: cobra.ExactArgs(1),
 	RunE: runReleaseDownload,
 }
@@ -109,13 +109,13 @@ var releaseDeleteCmd = &cobra.Command{
 	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
+  fgj release delete v1.0.0
 
   # Delete the latest release
-  fj release delete latest
+  fgj release delete latest
 
   # Delete without confirmation
-  fj release delete v1.0.0 -y`,
+  fgj release delete v1.0.0 -y`,
 	Args: cobra.ExactArgs(1),
 	RunE: runReleaseDelete,
 }
diff --git a/cmd/release_assets.go b/cmd/release_assets.go
new file mode 100644
index 0000000..14532b5
--- /dev/null
+++ b/cmd/release_assets.go
@@ -0,0 +1,310 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+
+	"code.gitea.io/sdk/gitea"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"forgejo.zerova.net/public/fgj-sid/internal/text"
+	"github.com/spf13/cobra"
+)
+
+var releaseAssetCmd = &cobra.Command{
+	Use:     "asset",
+	Aliases: []string{"assets"},
+	Short:   "Manage release assets",
+	Long:    "List, upload, and delete individual attachments on a release.",
+}
+
+var releaseAssetListCmd = &cobra.Command{
+	Use:   "list <tag|latest>",
+	Short: "List release assets",
+	Long:  "List attachments on a release identified by tag name (or \"latest\").",
+	Example: `  # List assets on a release
+  fgj release asset list v1.0.0
+
+  # List assets on the latest release as JSON
+  fgj release asset list latest --json`,
+	Args: cobra.ExactArgs(1),
+	RunE: runReleaseAssetList,
+}
+
+var releaseAssetCreateCmd = &cobra.Command{
+	Use:   "create <tag|latest> <files...>",
+	Short: "Upload one or more release assets",
+	Long:  "Upload one or more files as attachments to an existing release.",
+	Example: `  # Upload a single asset
+  fgj release asset create v1.0.0 dist/app-linux-amd64
+
+  # Upload multiple assets to the latest release
+  fgj release asset create latest dist/*.tar.gz
+
+  # Upload a single file under a different name
+  fgj release asset create v1.0.0 ./build/out --name app-v1.0.0`,
+	Args: cobra.MinimumNArgs(2),
+	RunE: runReleaseAssetCreate,
+}
+
+var releaseAssetDeleteCmd = &cobra.Command{
+	Use:   "delete <tag|latest> <asset-id-or-name>...",
+	Short: "Delete one or more release assets",
+	Long:  "Delete attachments from a release. Each argument may be a numeric asset ID or an asset filename.",
+	Example: `  # Delete by filename
+  fgj release asset delete v1.0.0 app-linux-amd64
+
+  # Delete multiple by ID
+  fgj release asset delete v1.0.0 42 43
+
+  # Skip confirmation
+  fgj release asset delete latest output.zip --yes`,
+	Args: cobra.MinimumNArgs(2),
+	RunE: runReleaseAssetDelete,
+}
+
+func init() {
+	releaseCmd.AddCommand(releaseAssetCmd)
+	releaseAssetCmd.AddCommand(releaseAssetListCmd)
+	releaseAssetCmd.AddCommand(releaseAssetCreateCmd)
+	releaseAssetCmd.AddCommand(releaseAssetDeleteCmd)
+
+	addRepoFlags(releaseAssetListCmd)
+	addJSONFlags(releaseAssetListCmd, "Output assets as JSON")
+
+	addRepoFlags(releaseAssetCreateCmd)
+	releaseAssetCreateCmd.Flags().String("name", "", "Override the uploaded filename (single file only)")
+
+	addRepoFlags(releaseAssetDeleteCmd)
+	releaseAssetDeleteCmd.Flags().BoolP("yes", "y", false, "Skip confirmation prompt")
+}
+
+func runReleaseAssetList(cmd *cobra.Command, args []string) error {
+	tag := args[0]
+
+	client, owner, name, err := newReleaseAssetClient(cmd)
+	if err != nil {
+		return err
+	}
+
+	ios.StartSpinner("Fetching release...")
+	release, err := getReleaseByTagOrLatest(client, owner, name, tag)
+	if err != nil {
+		ios.StopSpinner()
+		return err
+	}
+
+	var all []*gitea.Attachment
+	for page := 1; ; page++ {
+		attachments, _, err := client.ListReleaseAttachments(owner, name, release.ID, gitea.ListReleaseAttachmentsOptions{
+			ListOptions: gitea.ListOptions{Page: page, PageSize: 50},
+		})
+		if err != nil {
+			ios.StopSpinner()
+			return fmt.Errorf("failed to list release assets: %w", err)
+		}
+		if len(attachments) == 0 {
+			break
+		}
+		all = append(all, attachments...)
+	}
+	ios.StopSpinner()
+
+	if wantJSON(cmd) {
+		return outputJSON(cmd, all)
+	}
+
+	if len(all) == 0 {
+		fmt.Fprintf(ios.Out, "No assets on release %s\n", release.TagName)
+		return nil
+	}
+
+	isTTY := ios.IsStdoutTTY()
+	tp := ios.NewTablePrinter()
+	tp.AddHeader("ID", "NAME", "SIZE", "DOWNLOADS", "CREATED")
+	for _, a := range all {
+		tp.AddRow(
+			strconv.FormatInt(a.ID, 10),
+			a.Name,
+			humanSize(a.Size),
+			strconv.FormatInt(a.DownloadCount, 10),
+			text.FormatDate(a.Created, isTTY),
+		)
+	}
+	return tp.Render()
+}
+
+func runReleaseAssetCreate(cmd *cobra.Command, args []string) error {
+	tag := args[0]
+	files := args[1:]
+
+	nameOverride, _ := cmd.Flags().GetString("name")
+	if nameOverride != "" && len(files) != 1 {
+		return fmt.Errorf("--name may only be used when uploading a single file")
+	}
+
+	// Fail early if any file is missing.
+	for _, f := range files {
+		info, err := os.Stat(f)
+		if err != nil {
+			return fmt.Errorf("failed to stat %s: %w", f, err)
+		}
+		if info.IsDir() {
+			return fmt.Errorf("%s is a directory, not a file", f)
+		}
+	}
+
+	client, owner, name, err := newReleaseAssetClient(cmd)
+	if err != nil {
+		return err
+	}
+
+	ios.StartSpinner("Fetching release...")
+	release, err := getReleaseByTagOrLatest(client, owner, name, tag)
+	ios.StopSpinner()
+	if err != nil {
+		return err
+	}
+
+	cs := ios.ColorScheme()
+	for _, file := range files {
+		filename := filepath.Base(file)
+		if nameOverride != "" {
+			filename = nameOverride
+		}
+
+		handle, err := os.Open(file)
+		if err != nil {
+			return fmt.Errorf("failed to open %s: %w", file, err)
+		}
+
+		attachment, _, uploadErr := client.CreateReleaseAttachment(owner, name, release.ID, handle, filename)
+		closeErr := handle.Close()
+		if uploadErr != nil {
+			return fmt.Errorf("failed to upload %s: %w", file, uploadErr)
+		}
+		if closeErr != nil {
+			return fmt.Errorf("failed to close %s: %w", file, closeErr)
+		}
+
+		fmt.Fprintf(ios.Out, "%s Uploaded %s (id %d, %s)\n", cs.SuccessIcon(), attachment.Name, attachment.ID, humanSize(attachment.Size))
+	}
+
+	return nil
+}
+
+func runReleaseAssetDelete(cmd *cobra.Command, args []string) error {
+	tag := args[0]
+	targets := args[1:]
+	skipConfirm, _ := cmd.Flags().GetBool("yes")
+
+	client, owner, name, err := newReleaseAssetClient(cmd)
+	if err != nil {
+		return err
+	}
+
+	ios.StartSpinner("Fetching release...")
+	release, err := getReleaseByTagOrLatest(client, owner, name, tag)
+	ios.StopSpinner()
+	if err != nil {
+		return err
+	}
+
+	// Resolve each target to an attachment (ID + name). List attachments once
+	// if any target is a non-numeric name so we can match by filename.
+	var cached []*gitea.Attachment
+	resolvedIDs := make([]int64, 0, len(targets))
+	resolvedNames := make([]string, 0, len(targets))
+
+	for _, t := range targets {
+		if id, err := strconv.ParseInt(t, 10, 64); err == nil && id > 0 {
+			resolvedIDs = append(resolvedIDs, id)
+			resolvedNames = append(resolvedNames, t)
+			continue
+		}
+
+		if cached == nil {
+			cached, err = listReleaseAttachments(client, owner, name, release.ID)
+			if err != nil {
+				return err
+			}
+		}
+
+		var matched *gitea.Attachment
+		for _, a := range cached {
+			if a.Name == t {
+				matched = a
+				break
+			}
+		}
+		if matched == nil {
+			return fmt.Errorf("no asset named %q on release %s", t, release.TagName)
+		}
+		resolvedIDs = append(resolvedIDs, matched.ID)
+		resolvedNames = append(resolvedNames, matched.Name)
+	}
+
+	cs := ios.ColorScheme()
+	for i, id := range resolvedIDs {
+		display := resolvedNames[i]
+
+		if !skipConfirm && ios.IsStdinTTY() {
+			answer, err := promptLine(fmt.Sprintf("Delete asset %s (id %d) from release %s? [y/N]: ", display, id, release.TagName))
+			if err != nil {
+				return err
+			}
+			if answer != "y" && answer != "Y" && answer != "yes" {
+				fmt.Fprintf(ios.ErrOut, "Skipped %s\n", display)
+				continue
+			}
+		}
+
+		if _, err := client.DeleteReleaseAttachment(owner, name, release.ID, id); err != nil {
+			return fmt.Errorf("failed to delete asset %s: %w", display, err)
+		}
+
+		fmt.Fprintf(ios.Out, "%s Deleted asset %s (id %d)\n", cs.SuccessIcon(), display, id)
+	}
+
+	return nil
+}
+
+func newReleaseAssetClient(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
+}
+
+// humanSize formats a byte count using power-of-1024 units.
+func humanSize(n int64) string {
+	const unit = int64(1024)
+	if n < unit {
+		return fmt.Sprintf("%d B", n)
+	}
+	div, exp := unit, 0
+	for v := n / unit; v >= unit; v /= unit {
+		div *= unit
+		exp++
+	}
+	suffixes := []string{"KB", "MB", "GB", "TB", "PB", "EB"}
+	if exp >= len(suffixes) {
+		exp = len(suffixes) - 1
+	}
+	return fmt.Sprintf("%.1f %s", float64(n)/float64(div), suffixes[exp])
+}
diff --git a/cmd/repo.go b/cmd/repo.go
index 0514c4d..a9f62f6 100644
--- a/cmd/repo.go
+++ b/cmd/repo.go
@@ -8,9 +8,9 @@ import (
 	"strings"
 
 	"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"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"forgejo.zerova.net/public/fgj-sid/internal/text"
 	"github.com/spf13/cobra"
 )
 
@@ -67,22 +67,22 @@ var repoEditCmd = &cobra.Command{
 	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
+  fgj repo edit owner/repo --private
 
   # Make a repository public
-  fj repo edit owner/repo --public
+  fgj repo edit owner/repo --public
 
   # Update description and homepage
-  fj repo edit owner/repo -d "New description" --homepage https://example.com
+  fgj repo edit owner/repo -d "New description" --homepage https://example.com
 
   # Change default branch
-  fj repo edit --default-branch develop
+  fgj repo edit --default-branch develop
 
   # Rename a repository
-  fj repo edit owner/repo --name new-name
+  fgj repo edit owner/repo --name new-name
 
   # Edit current repo (auto-detected from git context)
-  fj repo edit --public`,
+  fgj repo edit --public`,
 	Args: cobra.MaximumNArgs(1),
 	RunE: runRepoEdit,
 }
@@ -90,12 +90,12 @@ var repoEditCmd = &cobra.Command{
 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>`.",
+	Long:  "Rename an existing repository. This is a shorthand for `fgj repo edit --name <new-name>`.",
 	Example: `  # Rename current repo
-  fj repo rename new-name
+  fgj repo rename new-name
 
   # Rename a specific repo
-  fj repo rename new-name -R owner/old-name`,
+  fgj repo rename new-name -R owner/old-name`,
 	Args: cobra.ExactArgs(1),
 	RunE: runRepoRename,
 }
@@ -216,18 +216,17 @@ func runRepoList(cmd *cobra.Command, args []string) error {
 		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
-	})
+	repos, _, err := client.ListUserRepos(user.UserName, gitea.ListReposOptions{})
 	ios.StopSpinner()
 	if err != nil {
 		return fmt.Errorf("failed to list repositories: %w", err)
 	}
 
+	limit, _ := cmd.Flags().GetInt("limit")
+	if limit > 0 && len(repos) > limit {
+		repos = repos[:limit]
+	}
+
 	if wantJSON(cmd) {
 		return outputJSON(cmd, repos)
 	}
diff --git a/cmd/repo_archive.go b/cmd/repo_archive.go
new file mode 100644
index 0000000..0c23f6a
--- /dev/null
+++ b/cmd/repo_archive.go
@@ -0,0 +1,163 @@
+package cmd
+
+import (
+	"fmt"
+
+	"code.gitea.io/sdk/gitea"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var repoArchiveCmd = &cobra.Command{
+	Use:   "archive [owner/name]",
+	Short: "Archive a repository",
+	Long: `Mark a repository as archived. Archived repositories remain visible but
+become read-only: pushes, issues, pull requests, and releases are disabled.
+
+The target repo may be passed as a positional argument, via -R/--repo, or
+auto-detected from the current git context. If both positional and -R are
+given, the -R flag wins.`,
+	Example: `  # Archive a specific repo (prompted confirmation)
+  fgj repo archive owner/name
+
+  # Archive the current repo without prompting
+  fgj repo archive --yes
+
+  # Archive using the -R flag
+  fgj repo archive -R owner/name -y`,
+	Args: cobra.MaximumNArgs(1),
+	RunE: runRepoArchive,
+}
+
+var repoUnarchiveCmd = &cobra.Command{
+	Use:   "unarchive [owner/name]",
+	Short: "Unarchive a repository",
+	Long: `Clear the archived flag on a repository, restoring normal read-write
+behaviour.
+
+The target repo may be passed as a positional argument, via -R/--repo, or
+auto-detected from the current git context. If both positional and -R are
+given, the -R flag wins.`,
+	Example: `  # Unarchive a specific repo
+  fgj repo unarchive owner/name
+
+  # Unarchive the current repo
+  fgj repo unarchive`,
+	Args: cobra.MaximumNArgs(1),
+	RunE: runRepoUnarchive,
+}
+
+func init() {
+	repoCmd.AddCommand(repoArchiveCmd)
+	repoCmd.AddCommand(repoUnarchiveCmd)
+
+	addRepoFlags(repoArchiveCmd)
+	repoArchiveCmd.Flags().BoolP("yes", "y", false, "Skip the confirmation prompt")
+	addJSONFlags(repoArchiveCmd, "Output updated repository as JSON")
+
+	addRepoFlags(repoUnarchiveCmd)
+	repoUnarchiveCmd.Flags().BoolP("yes", "y", false, "Skip the confirmation prompt (unused; kept for symmetry with archive)")
+	addJSONFlags(repoUnarchiveCmd, "Output updated repository as JSON")
+}
+
+// resolveRepoTarget returns owner/name honouring the "optional positional OR
+// -R flag" pattern used elsewhere in the CLI: -R wins when both are supplied.
+func resolveRepoTarget(cmd *cobra.Command, args []string) (string, string, error) {
+	var repo string
+	if len(args) > 0 {
+		repo = args[0]
+	}
+	if r, _ := cmd.Flags().GetString("repo"); r != "" {
+		repo = r
+	}
+	return parseRepo(repo)
+}
+
+func runRepoArchive(cmd *cobra.Command, args []string) error {
+	owner, name, err := resolveRepoTarget(cmd, args)
+	if err != nil {
+		return err
+	}
+
+	slug := fmt.Sprintf("%s/%s", owner, name)
+	skipConfirm, _ := cmd.Flags().GetBool("yes")
+
+	if !skipConfirm {
+		if !ios.IsStdinTTY() {
+			return fmt.Errorf("refusing to archive %s without a TTY; pass -y/--yes to confirm non-interactively", slug)
+		}
+		prompt := fmt.Sprintf("Archive %s? This disables issues/PRs/pushes. [y/N]: ", slug)
+		answer, err := promptLine(prompt)
+		if err != nil {
+			return err
+		}
+		if answer != "y" && answer != "Y" && answer != "yes" && answer != "Yes" && answer != "YES" {
+			fmt.Fprintln(ios.ErrOut, "Aborted.")
+			return nil
+		}
+	}
+
+	cfg, err := config.Load()
+	if err != nil {
+		return err
+	}
+	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	if err != nil {
+		return err
+	}
+
+	archived := true
+	opt := gitea.EditRepoOption{Archived: &archived}
+
+	ios.StartSpinner("Archiving repository...")
+	repository, _, err := client.EditRepo(owner, name, opt)
+	ios.StopSpinner()
+	if err != nil {
+		return fmt.Errorf("failed to archive %s: %w", slug, err)
+	}
+
+	if wantJSON(cmd) {
+		return outputJSON(cmd, repository)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Archived %s\n", cs.SuccessIcon(), slug)
+	return nil
+}
+
+func runRepoUnarchive(cmd *cobra.Command, args []string) error {
+	owner, name, err := resolveRepoTarget(cmd, args)
+	if err != nil {
+		return err
+	}
+
+	slug := fmt.Sprintf("%s/%s", owner, name)
+
+	cfg, err := config.Load()
+	if err != nil {
+		return err
+	}
+	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost(), getCwd())
+	if err != nil {
+		return err
+	}
+
+	archived := false
+	opt := gitea.EditRepoOption{Archived: &archived}
+
+	ios.StartSpinner("Unarchiving repository...")
+	repository, _, err := client.EditRepo(owner, name, opt)
+	ios.StopSpinner()
+	if err != nil {
+		return fmt.Errorf("failed to unarchive %s: %w", slug, err)
+	}
+
+	if wantJSON(cmd) {
+		return outputJSON(cmd, repository)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Unarchived %s\n", cs.SuccessIcon(), slug)
+	return nil
+}
diff --git a/cmd/repo_delete.go b/cmd/repo_delete.go
new file mode 100644
index 0000000..5cabe72
--- /dev/null
+++ b/cmd/repo_delete.go
@@ -0,0 +1,78 @@
+package cmd
+
+import (
+	"fmt"
+
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var repoDeleteCmd = &cobra.Command{
+	Use:     "delete [owner/name]",
+	Aliases: []string{"rm"},
+	Short:   "Delete a repository",
+	Long: `Delete a repository. This is irreversible and removes all issues, PRs,
+wikis, and release artifacts.
+
+For safety, you must either pass -y/--yes, or type the full owner/name
+string when prompted.`,
+	Example: `  # Delete a repository (prompted confirmation)
+  fgj repo delete owner/name
+
+  # Delete without confirmation (scripts)
+  fgj repo delete owner/name --yes`,
+	Args: cobra.MaximumNArgs(1),
+	RunE: runRepoDelete,
+}
+
+func init() {
+	repoCmd.AddCommand(repoDeleteCmd)
+	repoDeleteCmd.Flags().BoolP("yes", "y", false, "Skip the type-to-confirm prompt")
+}
+
+func runRepoDelete(cmd *cobra.Command, args []string) error {
+	var target string
+	if len(args) == 1 {
+		target = args[0]
+	}
+	owner, name, err := parseRepo(target)
+	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
+	}
+
+	slug := fmt.Sprintf("%s/%s", owner, name)
+	skipConfirm, _ := cmd.Flags().GetBool("yes")
+
+	if !skipConfirm {
+		if !ios.IsStdinTTY() {
+			return fmt.Errorf("refusing to delete %s without a TTY; pass --yes to confirm non-interactively", slug)
+		}
+		prompt := fmt.Sprintf("Type the full repo slug to confirm deletion (%s): ", slug)
+		answer, err := promptLine(prompt)
+		if err != nil {
+			return err
+		}
+		if answer != slug {
+			fmt.Fprintln(ios.ErrOut, "Confirmation mismatch; aborting.")
+			return nil
+		}
+	}
+
+	if _, err := client.DeleteRepo(owner, name); err != nil {
+		return fmt.Errorf("failed to delete %s: %w", slug, err)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Deleted %s\n", cs.SuccessIcon(), slug)
+	return nil
+}
diff --git a/cmd/repo_migrate.go b/cmd/repo_migrate.go
new file mode 100644
index 0000000..60e548c
--- /dev/null
+++ b/cmd/repo_migrate.go
@@ -0,0 +1,170 @@
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/spf13/cobra"
+)
+
+var repoMigrateCmd = &cobra.Command{
+	Use:     "migrate <clone-url>",
+	Aliases: []string{"m"},
+	Short:   "Migrate a repository from an external service",
+	Long: `Import a repository from GitHub, GitLab, Gogs, Gitea, or a plain Git
+remote. By default the migration is a one-shot import; pass --mirror
+to keep syncing on an interval.
+
+Authentication for the source repo is passed via --auth-token or
+--auth-username + --auth-password. Neither is stored after the
+migration completes on the server side.`,
+	Example: `  # Migrate a GitHub repo to this user's account
+  fgj repo migrate https://github.com/cli/cli \
+    --name gh-mirror --service github --auth-token "$GH_TOKEN"
+
+  # Mirror a plain Git remote into an org
+  fgj repo migrate https://example.com/project.git \
+    --name project --owner infrastructure --mirror --mirror-interval 8h
+
+  # Migrate with all content kinds
+  fgj repo migrate https://gitea.com/user/repo \
+    --name repo --service gitea --auth-token "$TOKEN" \
+    --wiki --labels --milestones --issues --pulls --releases --lfs`,
+	Args: cobra.ExactArgs(1),
+	RunE: runRepoMigrate,
+}
+
+func init() {
+	repoCmd.AddCommand(repoMigrateCmd)
+
+	repoMigrateCmd.Flags().String("name", "", "Name for the new repository (required)")
+	repoMigrateCmd.Flags().String("owner", "", "Owner (user or org) for the new repository (defaults to you)")
+	repoMigrateCmd.Flags().String("service", "git", "Source service: git, github, gitlab, gitea, gogs")
+	repoMigrateCmd.Flags().StringP("description", "d", "", "Description of the new repository")
+	repoMigrateCmd.Flags().String("auth-token", "", "Auth token for the source repo (preferred over username/password)")
+	repoMigrateCmd.Flags().String("auth-username", "", "Auth username for the source repo")
+	repoMigrateCmd.Flags().String("auth-password", "", "Auth password for the source repo")
+	repoMigrateCmd.Flags().Bool("private", false, "Make the new repository private")
+	repoMigrateCmd.Flags().Bool("mirror", false, "Mirror the source (keep syncing) instead of one-shot import")
+	repoMigrateCmd.Flags().String("mirror-interval", "", "Mirror sync interval (e.g. 8h, 24h); only with --mirror")
+	repoMigrateCmd.Flags().Bool("wiki", false, "Include wiki in the migration")
+	repoMigrateCmd.Flags().Bool("labels", false, "Include labels")
+	repoMigrateCmd.Flags().Bool("milestones", false, "Include milestones")
+	repoMigrateCmd.Flags().Bool("issues", false, "Include issues")
+	repoMigrateCmd.Flags().Bool("pulls", false, "Include pull requests")
+	repoMigrateCmd.Flags().Bool("releases", false, "Include releases")
+	repoMigrateCmd.Flags().Bool("lfs", false, "Include Git LFS content")
+	repoMigrateCmd.Flags().String("lfs-endpoint", "", "Explicit Git LFS server URL")
+
+	_ = repoMigrateCmd.MarkFlagRequired("name")
+	addJSONFlags(repoMigrateCmd, "Output created repository as JSON")
+}
+
+func runRepoMigrate(cmd *cobra.Command, args []string) error {
+	cloneURL := args[0]
+
+	repoName, _ := cmd.Flags().GetString("name")
+	if strings.TrimSpace(repoName) == "" {
+		return fmt.Errorf("--name is required")
+	}
+
+	owner, _ := cmd.Flags().GetString("owner")
+	serviceStr, _ := cmd.Flags().GetString("service")
+
+	service, err := parseGitService(serviceStr)
+	if err != nil {
+		return err
+	}
+
+	client, err := loadClient()
+	if err != nil {
+		return err
+	}
+
+	// Default owner = authenticated user.
+	if owner == "" {
+		user, _, err := client.GetMyUserInfo()
+		if err != nil {
+			return fmt.Errorf("failed to resolve current user (pass --owner to override): %w", err)
+		}
+		owner = user.UserName
+	}
+
+	description, _ := cmd.Flags().GetString("description")
+	authToken, _ := cmd.Flags().GetString("auth-token")
+	authUser, _ := cmd.Flags().GetString("auth-username")
+	authPass, _ := cmd.Flags().GetString("auth-password")
+	private, _ := cmd.Flags().GetBool("private")
+	mirror, _ := cmd.Flags().GetBool("mirror")
+	mirrorInterval, _ := cmd.Flags().GetString("mirror-interval")
+	if mirrorInterval != "" && !mirror {
+		return fmt.Errorf("--mirror-interval requires --mirror")
+	}
+
+	wiki, _ := cmd.Flags().GetBool("wiki")
+	labels, _ := cmd.Flags().GetBool("labels")
+	milestones, _ := cmd.Flags().GetBool("milestones")
+	issues, _ := cmd.Flags().GetBool("issues")
+	pulls, _ := cmd.Flags().GetBool("pulls")
+	releases, _ := cmd.Flags().GetBool("releases")
+	lfs, _ := cmd.Flags().GetBool("lfs")
+	lfsEndpoint, _ := cmd.Flags().GetString("lfs-endpoint")
+
+	opt := gitea.MigrateRepoOption{
+		RepoName:       repoName,
+		RepoOwner:      owner,
+		CloneAddr:      cloneURL,
+		Service:        service,
+		AuthUsername:   authUser,
+		AuthPassword:   authPass,
+		AuthToken:      authToken,
+		Private:        private,
+		Description:    description,
+		Mirror:         mirror,
+		MirrorInterval: mirrorInterval,
+		Wiki:           wiki,
+		Labels:         labels,
+		Milestones:     milestones,
+		Issues:         issues,
+		PullRequests:   pulls,
+		Releases:       releases,
+		LFS:            lfs,
+		LFSEndpoint:    lfsEndpoint,
+	}
+
+	ios.StartSpinner("Starting migration...")
+	repo, _, err := client.MigrateRepo(opt)
+	ios.StopSpinner()
+	if err != nil {
+		return fmt.Errorf("migration failed: %w", err)
+	}
+
+	if wantJSON(cmd) {
+		return outputJSON(cmd, repo)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Migrated to %s\n", cs.SuccessIcon(), repo.FullName)
+	if repo.HTMLURL != "" {
+		fmt.Fprintf(ios.Out, "  %s\n", repo.HTMLURL)
+	}
+	return nil
+}
+
+func parseGitService(s string) (gitea.GitServiceType, error) {
+	switch strings.ToLower(s) {
+	case "", "git", "plain":
+		return gitea.GitServicePlain, nil
+	case "github":
+		return gitea.GitServiceGithub, nil
+	case "gitlab":
+		return gitea.GitServiceGitlab, nil
+	case "gitea", "forgejo":
+		return gitea.GitServiceGitea, nil
+	case "gogs":
+		return gitea.GitServiceGogs, nil
+	default:
+		return "", fmt.Errorf("unknown --service %q (expected: git, github, gitlab, gitea, gogs)", s)
+	}
+}
diff --git a/cmd/repo_search.go b/cmd/repo_search.go
new file mode 100644
index 0000000..a67eed3
--- /dev/null
+++ b/cmd/repo_search.go
@@ -0,0 +1,146 @@
+package cmd
+
+import (
+	"fmt"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/spf13/cobra"
+)
+
+var repoSearchCmd = &cobra.Command{
+	Use:     "search [query]",
+	Aliases: []string{"s"},
+	Short:   "Search repositories on the current host",
+	Long: `Search repositories using the host's search index.
+
+The query is matched against name by default. Pass --topic to match against
+topics only, or --description to include descriptions. --type limits results
+to "source" (non-fork, non-mirror), "fork", or "mirror" repositories.`,
+	Example: `  # Search by name substring
+  fgj repo search tea
+
+  # Search by topic
+  fgj repo search ci --topic
+
+  # Find only forks
+  fgj repo search go --type fork
+
+  # List private repos owned by a user (no query)
+  fgj repo search --owner alice --private --limit 50
+
+  # Output as JSON
+  fgj repo search platform --json`,
+	Args: cobra.MaximumNArgs(1),
+	RunE: runRepoSearch,
+}
+
+func init() {
+	repoCmd.AddCommand(repoSearchCmd)
+
+	repoSearchCmd.Flags().Bool("topic", false, "Match query against topics only")
+	repoSearchCmd.Flags().Bool("description", false, "Include descriptions in the search")
+	repoSearchCmd.Flags().Bool("private", false, "Limit to private repositories")
+	repoSearchCmd.Flags().Bool("archived", false, "Include archived repositories")
+	repoSearchCmd.Flags().Bool("exclude-templates", false, "Exclude template repositories")
+	repoSearchCmd.Flags().String("type", "", "Filter by repo type: source, fork, mirror")
+	repoSearchCmd.Flags().String("owner", "", "Limit to repos owned by this user or org")
+	repoSearchCmd.Flags().String("sort", "", "Sort by: alpha, created, updated, size, id")
+	repoSearchCmd.Flags().String("order", "", "Order: asc or desc")
+	repoSearchCmd.Flags().IntP("limit", "L", 30, "Maximum number of results")
+
+	addJSONFlags(repoSearchCmd, "Output as JSON")
+}
+
+func runRepoSearch(cmd *cobra.Command, args []string) error {
+	client, err := loadClient()
+	if err != nil {
+		return err
+	}
+
+	query := ""
+	if len(args) == 1 {
+		query = args[0]
+	}
+
+	topic, _ := cmd.Flags().GetBool("topic")
+	desc, _ := cmd.Flags().GetBool("description")
+	private, _ := cmd.Flags().GetBool("private")
+	archived, _ := cmd.Flags().GetBool("archived")
+	excludeTemplates, _ := cmd.Flags().GetBool("exclude-templates")
+	sort, _ := cmd.Flags().GetString("sort")
+	order, _ := cmd.Flags().GetString("order")
+	typeFlag, _ := cmd.Flags().GetString("type")
+	limit, _ := cmd.Flags().GetInt("limit")
+	if limit <= 0 {
+		limit = 30
+	}
+
+	var repoType gitea.RepoType
+	switch typeFlag {
+	case "":
+		repoType = gitea.RepoTypeNone
+	case "source":
+		repoType = gitea.RepoTypeSource
+	case "fork":
+		repoType = gitea.RepoTypeFork
+	case "mirror":
+		repoType = gitea.RepoTypeMirror
+	default:
+		return fmt.Errorf("invalid --type %q (must be source, fork, or mirror)", typeFlag)
+	}
+
+	opt := gitea.SearchRepoOptions{
+		ListOptions:          gitea.ListOptions{PageSize: limit},
+		Keyword:              query,
+		KeywordIsTopic:       topic,
+		KeywordInDescription: desc,
+		IsPrivate:            optionalBool(private),
+		IsArchived:           optionalBool(archived),
+		ExcludeTemplate:      excludeTemplates,
+		Type:                 repoType,
+		Sort:                 sort,
+		Order:                order,
+	}
+
+	if o, _ := cmd.Flags().GetString("owner"); o != "" {
+		u, _, err := client.GetUserInfo(o)
+		if err != nil {
+			return fmt.Errorf("failed to resolve owner %q: %w", o, err)
+		}
+		opt.OwnerID = u.ID
+	}
+
+	repos, _, err := client.SearchRepos(opt)
+	if err != nil {
+		return fmt.Errorf("search failed: %w", err)
+	}
+
+	if wantJSON(cmd) {
+		return outputJSON(cmd, repos)
+	}
+
+	if len(repos) == 0 {
+		fmt.Fprintln(ios.Out, "No repositories match.")
+		return nil
+	}
+
+	tp := ios.NewTablePrinter()
+	tp.AddHeader("FULL NAME", "VISIBILITY", "DESCRIPTION", "STARS")
+	for _, r := range repos {
+		visibility := "public"
+		if r.Private {
+			visibility = "private"
+		}
+		tp.AddRow(r.FullName, visibility, r.Description, fmt.Sprintf("%d", r.Stars))
+	}
+	return tp.Render()
+}
+
+// optionalBool returns a pointer when the user explicitly wants the positive
+// filter (IsPrivate/IsArchived); nil means "no filter" to the SDK.
+func optionalBool(v bool) *bool {
+	if !v {
+		return nil
+	}
+	return &v
+}
diff --git a/cmd/repo_template.go b/cmd/repo_template.go
new file mode 100644
index 0000000..0a82faf
--- /dev/null
+++ b/cmd/repo_template.go
@@ -0,0 +1,113 @@
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	"code.gitea.io/sdk/gitea"
+	"github.com/spf13/cobra"
+)
+
+var repoCreateFromTemplateCmd = &cobra.Command{
+	Use:     "create-from-template <template-owner/template-name> <new-name>",
+	Aliases: []string{"ct"},
+	Short:   "Create a repository from a template",
+	Long: `Scaffold a new repository based on an existing template repository.
+
+By default this copies only the default branch content. Pass --with-<kind>
+flags to include topics, labels, webhooks, git hooks, and other template
+metadata.`,
+	Example: `  # Create a new repo under your account from a template
+  fgj repo create-from-template org/template-name my-new-repo
+
+  # Target a specific owner and make it private
+  fgj repo create-from-template org/template-name new-repo --owner myorg --private
+
+  # Copy everything: content, topics, labels, webhooks, hooks, avatar
+  fgj repo create-from-template org/template-name new-repo \
+    --with-content --with-topics --with-labels \
+    --with-webhooks --with-git-hooks --with-avatar`,
+	Args: cobra.ExactArgs(2),
+	RunE: runRepoCreateFromTemplate,
+}
+
+func init() {
+	repoCmd.AddCommand(repoCreateFromTemplateCmd)
+
+	repoCreateFromTemplateCmd.Flags().String("owner", "", "Owner (user or org) for the new repository (defaults to you)")
+	repoCreateFromTemplateCmd.Flags().StringP("description", "d", "", "Description for the new repository")
+	repoCreateFromTemplateCmd.Flags().Bool("private", false, "Make the new repository private")
+	repoCreateFromTemplateCmd.Flags().Bool("with-content", true, "Include default branch content from the template")
+	repoCreateFromTemplateCmd.Flags().Bool("with-topics", false, "Include topics from the template")
+	repoCreateFromTemplateCmd.Flags().Bool("with-labels", false, "Include labels from the template")
+	repoCreateFromTemplateCmd.Flags().Bool("with-webhooks", false, "Include webhooks from the template")
+	repoCreateFromTemplateCmd.Flags().Bool("with-git-hooks", false, "Include git hooks from the template")
+	repoCreateFromTemplateCmd.Flags().Bool("with-avatar", false, "Include the template repo's avatar")
+
+	addJSONFlags(repoCreateFromTemplateCmd, "Output created repository as JSON")
+}
+
+func runRepoCreateFromTemplate(cmd *cobra.Command, args []string) error {
+	templateSlug := args[0]
+	newName := args[1]
+
+	parts := strings.SplitN(templateSlug, "/", 2)
+	if len(parts) != 2 || parts[0] == "" || parts[1] == "" {
+		return fmt.Errorf("template must be in owner/name format (got %q)", templateSlug)
+	}
+	templateOwner, templateName := parts[0], parts[1]
+
+	client, err := loadClient()
+	if err != nil {
+		return err
+	}
+
+	owner, _ := cmd.Flags().GetString("owner")
+	if owner == "" {
+		user, _, err := client.GetMyUserInfo()
+		if err != nil {
+			return fmt.Errorf("failed to resolve current user (pass --owner to override): %w", err)
+		}
+		owner = user.UserName
+	}
+
+	description, _ := cmd.Flags().GetString("description")
+	private, _ := cmd.Flags().GetBool("private")
+	withContent, _ := cmd.Flags().GetBool("with-content")
+	withTopics, _ := cmd.Flags().GetBool("with-topics")
+	withLabels, _ := cmd.Flags().GetBool("with-labels")
+	withWebhooks, _ := cmd.Flags().GetBool("with-webhooks")
+	withGitHooks, _ := cmd.Flags().GetBool("with-git-hooks")
+	withAvatar, _ := cmd.Flags().GetBool("with-avatar")
+
+	opt := gitea.CreateRepoFromTemplateOption{
+		Owner:       owner,
+		Name:        newName,
+		Description: description,
+		Private:     private,
+		GitContent:  withContent,
+		Topics:      withTopics,
+		Labels:      withLabels,
+		Webhooks:    withWebhooks,
+		GitHooks:    withGitHooks,
+		Avatar:      withAvatar,
+	}
+
+	ios.StartSpinner("Creating from template...")
+	repo, _, err := client.CreateRepoFromTemplate(templateOwner, templateName, opt)
+	ios.StopSpinner()
+	if err != nil {
+		return fmt.Errorf("template instantiation failed: %w", err)
+	}
+
+	if wantJSON(cmd) {
+		return outputJSON(cmd, repo)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Created %s from template %s\n", cs.SuccessIcon(), repo.FullName, templateSlug)
+	if repo.HTMLURL != "" {
+		fmt.Fprintf(ios.Out, "  %s\n", repo.HTMLURL)
+	}
+	return nil
+}
diff --git a/cmd/root.go b/cmd/root.go
index 8b4dcef..eaecb28 100644
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -2,14 +2,11 @@ package cmd
 
 import (
 	"fmt"
-	"io"
 	"os"
-	"path/filepath"
 	"strconv"
 	"strings"
 
-	"forgejo.zerova.net/public/fj/internal/config"
-	"forgejo.zerova.net/public/fj/internal/git"
+	"forgejo.zerova.net/public/fgj-sid/internal/git"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -17,12 +14,16 @@ import (
 var cfgFile string
 var jsonErrors bool
 
+// version is set at build time via -ldflags "-X .../cmd.version=...".
+// Defaults to "dev" for plain `go build` / `go run`.
+var version = "dev"
+
 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",
+	Version:       version,
 	SilenceErrors: true,
 }
 
@@ -38,7 +39,7 @@ func Execute() error {
 func init() {
 	cobra.OnInitialize(initConfig)
 
-	rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.config/fj/config.yaml)")
+	rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.config/fgj/config.yaml)")
 	rootCmd.PersistentFlags().BoolVar(&jsonErrors, "json-errors", false, "output errors as structured JSON to stderr")
 	rootCmd.PersistentFlags().String("hostname", "", "Forgejo instance hostname")
 	_ = viper.BindPFlag("hostname", rootCmd.PersistentFlags().Lookup("hostname"))
@@ -46,12 +47,7 @@ func init() {
 
 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 {
@@ -59,20 +55,8 @@ func initConfig() {
 			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,17 +64,9 @@ 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".
@@ -155,51 +131,3 @@ func parseIssueArg(arg string) (int64, error) {
 	}
 	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/secret_input.go b/cmd/secret_input.go
new file mode 100644
index 0000000..98bbca9
--- /dev/null
+++ b/cmd/secret_input.go
@@ -0,0 +1,68 @@
+package cmd
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/spf13/cobra"
+	"golang.org/x/term"
+)
+
+// readSecretValue resolves the value for a secret/token flag from, in order:
+//  1. --body (inline; visible in shell history)
+//  2. --body-file (file path, or "-" for stdin)
+//  3. interactive TTY prompt (hidden)
+//  4. piped stdin
+//
+// Trailing whitespace (including the final newline common in heredocs and
+// `echo ... | fgj ...`) is trimmed. An empty resolved value is rejected so we
+// never silently write an empty secret.
+func readSecretValue(cmd *cobra.Command, label string) (string, error) {
+	if v, _ := cmd.Flags().GetString("body"); v != "" {
+		return strings.TrimRight(v, "\r\n"), nil
+	}
+
+	if path, _ := cmd.Flags().GetString("body-file"); path != "" {
+		var raw []byte
+		var err error
+		if path == "-" {
+			raw, err = io.ReadAll(ios.In)
+		} else {
+			raw, err = os.ReadFile(path)
+		}
+		if err != nil {
+			return "", fmt.Errorf("failed to read secret from %q: %w", path, err)
+		}
+		value := strings.TrimRight(string(raw), "\r\n")
+		if value == "" {
+			return "", fmt.Errorf("secret value from %q is empty", path)
+		}
+		return value, nil
+	}
+
+	if ios.IsStdinTTY() {
+		fmt.Fprintf(ios.ErrOut, "Value for %s: ", label)
+		pw, err := term.ReadPassword(int(os.Stdin.Fd()))
+		fmt.Fprintln(ios.ErrOut)
+		if err != nil {
+			return "", fmt.Errorf("failed to read secret: %w", err)
+		}
+		value := strings.TrimRight(string(pw), "\r\n")
+		if value == "" {
+			return "", fmt.Errorf("secret value is empty")
+		}
+		return value, nil
+	}
+
+	raw, err := io.ReadAll(ios.In)
+	if err != nil {
+		return "", fmt.Errorf("failed to read secret from stdin: %w", err)
+	}
+	value := strings.TrimRight(string(raw), "\r\n")
+	if value == "" {
+		return "", fmt.Errorf("secret value from stdin is empty")
+	}
+	return value, nil
+}
diff --git a/cmd/times.go b/cmd/times.go
new file mode 100644
index 0000000..d8fc8d3
--- /dev/null
+++ b/cmd/times.go
@@ -0,0 +1,386 @@
+package cmd
+
+import (
+	"fmt"
+	"time"
+
+	"code.gitea.io/sdk/gitea"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var timeCmd = &cobra.Command{
+	Use:     "time",
+	Aliases: []string{"times", "t"},
+	Short:   "Manage tracked time entries",
+	Long: `Manage tracked time entries on issues and pull requests.
+
+Time tracking must be enabled on the repository for add/delete/reset to succeed.
+Durations are parsed with Go's time.ParseDuration, so values like "30m", "1h30m",
+"2h", or "45s" are all accepted.`,
+}
+
+var timeListCmd = &cobra.Command{
+	Use:   "list [issue-number]",
+	Short: "List tracked time entries",
+	Long: `List tracked time entries.
+
+When no issue number is given, shows the authenticated user's tracked times
+across all repositories on the current host. When an issue number is given,
+shows the tracked times recorded against that issue in the current repository
+(or the repository selected with -R/--repo).
+
+The issue argument may be a bare number (123), a "#"-prefixed number (#123),
+or a full issue URL.`,
+	Example: `  # List your tracked times across all repos
+  fgj time list
+
+  # List tracked times on issue #42 in the current repo
+  fgj time list 42
+
+  # List tracked times on issue #42 in a specific repo
+  fgj time list 42 -R owner/repo
+
+  # Output as JSON
+  fgj time list --json
+  fgj time list 42 --json`,
+	Args: cobra.MaximumNArgs(1),
+	RunE: runTimeList,
+}
+
+var timeAddCmd = &cobra.Command{
+	Use:   "add <issue-number> <duration>",
+	Short: "Add a tracked time entry to an issue",
+	Long: `Add a tracked time entry to an issue or pull request.
+
+The duration argument accepts any string that Go's time.ParseDuration
+understands, for example:
+
+  30s        thirty seconds
+  45m        forty-five minutes
+  1h         one hour
+  1h30m      ninety minutes
+  2h15m30s   two hours, fifteen minutes, thirty seconds
+
+The value is rounded down to whole seconds before being sent to the server.
+The issue argument may be a bare number, #-prefixed, or an issue URL.`,
+	Example: `  # Add 30 minutes to issue #42 in the current repo
+  fgj time add 42 30m
+
+  # Add 1h 30m to issue #7 in another repo
+  fgj time add 7 1h30m -R owner/repo
+
+  # Add just a few seconds (useful for testing)
+  fgj time add #42 45s`,
+	Args: cobra.ExactArgs(2),
+	RunE: runTimeAdd,
+}
+
+var timeDeleteCmd = &cobra.Command{
+	Use:     "delete <issue-number> <time-id>",
+	Aliases: []string{"rm"},
+	Short:   "Delete a specific tracked time entry",
+	Long: `Delete a single tracked time entry from an issue by its entry ID.
+
+Use "fgj time list <issue-number>" to find the ID of the entry you want to
+remove. A confirmation prompt is shown unless --yes is passed or stdin is
+not a TTY.`,
+	Example: `  # Delete tracked time entry 123 from issue #42
+  fgj time delete 42 123
+
+  # Delete without confirmation
+  fgj time delete 42 123 --yes
+
+  # Target a specific repository
+  fgj time rm 42 123 -R owner/repo`,
+	Args: cobra.ExactArgs(2),
+	RunE: runTimeDelete,
+}
+
+var timeResetCmd = &cobra.Command{
+	Use:   "reset <issue-number>",
+	Short: "Delete all tracked time entries on an issue",
+	Long: `Reset (delete all) tracked time entries on an issue or pull request.
+
+This removes every time entry recorded against the issue, regardless of who
+logged it. A confirmation prompt is shown unless --yes is passed or stdin is
+not a TTY.`,
+	Example: `  # Reset tracked times on issue #42 in the current repo
+  fgj time reset 42
+
+  # Reset without confirmation
+  fgj time reset 42 --yes
+
+  # Reset in a specific repo
+  fgj time reset 42 -R owner/repo`,
+	Args: cobra.ExactArgs(1),
+	RunE: runTimeReset,
+}
+
+func init() {
+	rootCmd.AddCommand(timeCmd)
+	timeCmd.AddCommand(timeListCmd)
+	timeCmd.AddCommand(timeAddCmd)
+	timeCmd.AddCommand(timeDeleteCmd)
+	timeCmd.AddCommand(timeResetCmd)
+
+	addRepoFlags(timeListCmd)
+	addJSONFlags(timeListCmd, "Output as JSON")
+
+	addRepoFlags(timeAddCmd)
+
+	addRepoFlags(timeDeleteCmd)
+	timeDeleteCmd.Flags().BoolP("yes", "y", false, "Skip confirmation prompt")
+
+	addRepoFlags(timeResetCmd)
+	timeResetCmd.Flags().BoolP("yes", "y", false, "Skip confirmation prompt")
+}
+
+func runTimeList(cmd *cobra.Command, args []string) error {
+	// No issue argument: list the authenticated user's tracked times across
+	// all repos on the current host. This path does not require a repo
+	// context, so we use loadClient.
+	if len(args) == 0 {
+		client, err := loadClient()
+		if err != nil {
+			return err
+		}
+
+		times, _, err := client.ListMyTrackedTimes(gitea.ListTrackedTimesOptions{})
+		if err != nil {
+			return fmt.Errorf("failed to list tracked times: %w", err)
+		}
+
+		if wantJSON(cmd) {
+			return outputJSON(cmd, times)
+		}
+
+		return renderTimesTable(times, true)
+	}
+
+	// Issue-scoped list.
+	index, err := parseIssueArg(args[0])
+	if err != nil {
+		return fmt.Errorf("invalid issue %q: %w", args[0], err)
+	}
+
+	client, owner, repoName, err := newTimeClient(cmd)
+	if err != nil {
+		return err
+	}
+
+	times, _, err := client.ListIssueTrackedTimes(owner, repoName, index, gitea.ListTrackedTimesOptions{})
+	if err != nil {
+		return fmt.Errorf("failed to list tracked times for %s/%s#%d: %w", owner, repoName, index, err)
+	}
+
+	if wantJSON(cmd) {
+		return outputJSON(cmd, times)
+	}
+
+	return renderTimesTable(times, true)
+}
+
+func runTimeAdd(cmd *cobra.Command, args []string) error {
+	index, err := parseIssueArg(args[0])
+	if err != nil {
+		return fmt.Errorf("invalid issue %q: %w", args[0], err)
+	}
+
+	dur, err := time.ParseDuration(args[1])
+	if err != nil {
+		return fmt.Errorf("invalid duration %q (expected a Go duration like 30m, 1h30m, 2h): %w", args[1], err)
+	}
+	seconds := int64(dur.Seconds())
+	if seconds <= 0 {
+		return fmt.Errorf("duration must be greater than zero seconds")
+	}
+
+	client, owner, repoName, err := newTimeClient(cmd)
+	if err != nil {
+		return err
+	}
+
+	tt, _, err := client.AddTime(owner, repoName, index, gitea.AddTimeOption{
+		Time:    seconds,
+		Created: time.Time{},
+		User:    "",
+	})
+	if err != nil {
+		return fmt.Errorf("failed to add tracked time to %s/%s#%d: %w", owner, repoName, index, err)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Added %s to %s/%s#%d (entry %d)\n",
+		cs.SuccessIcon(), formatDurationSeconds(tt.Time), owner, repoName, index, tt.ID)
+	return nil
+}
+
+func runTimeDelete(cmd *cobra.Command, args []string) error {
+	index, err := parseIssueArg(args[0])
+	if err != nil {
+		return fmt.Errorf("invalid issue %q: %w", args[0], err)
+	}
+
+	timeID, err := parseIssueArg(args[1])
+	if err != nil {
+		return fmt.Errorf("invalid time id %q: %w", args[1], err)
+	}
+
+	client, owner, repoName, err := newTimeClient(cmd)
+	if err != nil {
+		return err
+	}
+
+	skipConfirm, _ := cmd.Flags().GetBool("yes")
+	if !skipConfirm && ios.IsStdinTTY() {
+		answer, err := promptLine(fmt.Sprintf("Delete tracked time entry %d on %s/%s#%d? [y/N]: ", timeID, owner, repoName, index))
+		if err != nil {
+			return err
+		}
+		if answer != "y" && answer != "Y" && answer != "yes" {
+			fmt.Fprintln(ios.ErrOut, "Cancelled.")
+			return nil
+		}
+	}
+
+	if _, err := client.DeleteTime(owner, repoName, index, timeID); err != nil {
+		return fmt.Errorf("failed to delete tracked time entry %d on %s/%s#%d: %w", timeID, owner, repoName, index, err)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Deleted tracked time entry %d on %s/%s#%d\n", cs.SuccessIcon(), timeID, owner, repoName, index)
+	return nil
+}
+
+func runTimeReset(cmd *cobra.Command, args []string) error {
+	index, err := parseIssueArg(args[0])
+	if err != nil {
+		return fmt.Errorf("invalid issue %q: %w", args[0], err)
+	}
+
+	client, owner, repoName, err := newTimeClient(cmd)
+	if err != nil {
+		return err
+	}
+
+	skipConfirm, _ := cmd.Flags().GetBool("yes")
+	if !skipConfirm && ios.IsStdinTTY() {
+		answer, err := promptLine(fmt.Sprintf("Delete ALL tracked time entries on %s/%s#%d? [y/N]: ", owner, repoName, index))
+		if err != nil {
+			return err
+		}
+		if answer != "y" && answer != "Y" && answer != "yes" {
+			fmt.Fprintln(ios.ErrOut, "Cancelled.")
+			return nil
+		}
+	}
+
+	if _, err := client.ResetIssueTime(owner, repoName, index); err != nil {
+		return fmt.Errorf("failed to reset tracked times on %s/%s#%d: %w", owner, repoName, index, err)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Reset tracked times on %s/%s#%d\n", cs.SuccessIcon(), owner, repoName, index)
+	return nil
+}
+
+// renderTimesTable prints a table of tracked time entries. When showRepo is
+// true the ISSUE column includes the owner/repo prefix (useful for the
+// cross-repo "list my times" view).
+func renderTimesTable(times []*gitea.TrackedTime, showRepo bool) error {
+	if len(times) == 0 {
+		fmt.Fprintln(ios.Out, "No tracked time entries.")
+		return nil
+	}
+
+	tp := ios.NewTablePrinter()
+	tp.AddHeader("ID", "DATE", "USER", "ISSUE", "TIME")
+	for _, t := range times {
+		date := ""
+		if !t.Created.IsZero() {
+			date = t.Created.Local().Format("2006-01-02")
+		}
+
+		issueCol := ""
+		if t.Issue != nil {
+			if showRepo && t.Issue.Repository != nil && t.Issue.Repository.FullName != "" {
+				issueCol = fmt.Sprintf("%s#%d", t.Issue.Repository.FullName, t.Issue.Index)
+			} else {
+				issueCol = fmt.Sprintf("#%d", t.Issue.Index)
+			}
+		} else if t.IssueID != 0 {
+			issueCol = fmt.Sprintf("#%d", t.IssueID)
+		}
+
+		tp.AddRow(
+			fmt.Sprintf("%d", t.ID),
+			date,
+			t.UserName,
+			issueCol,
+			formatDurationSeconds(t.Time),
+		)
+	}
+	return tp.Render()
+}
+
+// formatDurationSeconds renders a seconds count as a compact human duration.
+// Examples: 0 -> "0m", 45 -> "45s", 90 -> "1m 30s", 3600 -> "1h",
+// 5400 -> "1h 30m", 3661 -> "1h 1m 1s".
+func formatDurationSeconds(seconds int64) string {
+	if seconds <= 0 {
+		return "0m"
+	}
+
+	h := seconds / 3600
+	m := (seconds % 3600) / 60
+	s := seconds % 60
+
+	parts := make([]string, 0, 3)
+	if h > 0 {
+		parts = append(parts, fmt.Sprintf("%dh", h))
+	}
+	if m > 0 {
+		parts = append(parts, fmt.Sprintf("%dm", m))
+	}
+	if s > 0 && h == 0 {
+		// Only show seconds when the duration is under an hour; keeps the
+		// table tidy for long entries where the second-level detail is
+		// rarely interesting.
+		parts = append(parts, fmt.Sprintf("%ds", s))
+	}
+	if len(parts) == 0 {
+		return "0m"
+	}
+
+	// Join with spaces: "1h 30m".
+	out := parts[0]
+	for _, p := range parts[1:] {
+		out += " " + p
+	}
+	return out
+}
+
+// newTimeClient builds an api.Client plus the resolved owner/repo from the
+// current -R/--repo flag or the surrounding git context. Used by every
+// repo-scoped subcommand (add, delete, reset, and issue-scoped list).
+func newTimeClient(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
+}
diff --git a/cmd/webhook.go b/cmd/webhook.go
new file mode 100644
index 0000000..5b9a6cb
--- /dev/null
+++ b/cmd/webhook.go
@@ -0,0 +1,293 @@
+package cmd
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"code.gitea.io/sdk/gitea"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var webhookCmd = &cobra.Command{
+	Use:     "webhook",
+	Aliases: []string{"webhooks", "hook"},
+	Short:   "Manage repository webhooks",
+	Long:    "List, create, update, and delete webhooks attached to a repository.",
+}
+
+var webhookListCmd = &cobra.Command{
+	Use:     "list",
+	Aliases: []string{"ls"},
+	Short:   "List webhooks for a repository",
+	Example: `  # List webhooks on the current repository
+  fgj webhook list
+
+  # List with JSON output
+  fgj webhook list --json`,
+	RunE: runWebhookList,
+}
+
+var webhookCreateCmd = &cobra.Command{
+	Use:   "create <url>",
+	Short: "Create a repository webhook",
+	Long: `Create a webhook that delivers events to <url>.
+
+Event names follow the Gitea/Forgejo webhook event model: push, pull_request,
+issues, issue_comment, release, create, delete, fork, wiki, repository, and others.
+Omit --events to deliver only the default (push).`,
+	Example: `  # Create a Gitea-format push webhook
+  fgj webhook create https://example.com/hook
+
+  # Multiple events and a content type
+  fgj webhook create https://ci.example.com/hook \
+    --events push,pull_request,release \
+    --content-type application/json \
+    --secret "$HOOK_SECRET"
+
+  # Slack-style webhook
+  fgj webhook create https://hooks.slack.com/services/XXX --type slack`,
+	Args: cobra.ExactArgs(1),
+	RunE: runWebhookCreate,
+}
+
+var webhookUpdateCmd = &cobra.Command{
+	Use:     "update <id>",
+	Aliases: []string{"edit"},
+	Short:   "Update a repository webhook",
+	Long:    "Update an existing webhook. Flags you omit are left unchanged.",
+	Args:    cobra.ExactArgs(1),
+	Example: `  # Disable a webhook
+  fgj webhook update 12 --active=false
+
+  # Change events and URL
+  fgj webhook update 12 --url https://new.example.com/hook --events push,release`,
+	RunE: runWebhookUpdate,
+}
+
+var webhookDeleteCmd = &cobra.Command{
+	Use:     "delete <id>",
+	Aliases: []string{"rm"},
+	Short:   "Delete a repository webhook",
+	Args:    cobra.ExactArgs(1),
+	RunE:    runWebhookDelete,
+}
+
+func init() {
+	rootCmd.AddCommand(webhookCmd)
+	webhookCmd.AddCommand(webhookListCmd)
+	webhookCmd.AddCommand(webhookCreateCmd)
+	webhookCmd.AddCommand(webhookUpdateCmd)
+	webhookCmd.AddCommand(webhookDeleteCmd)
+
+	addRepoFlags(webhookListCmd)
+	addJSONFlags(webhookListCmd, "Output as JSON")
+
+	addRepoFlags(webhookCreateCmd)
+	webhookCreateCmd.Flags().String("type", "gitea", "Hook type (gitea, slack, discord, msteams, telegram, feishu, gogs)")
+	webhookCreateCmd.Flags().StringSlice("events", []string{"push"}, "Events to deliver (comma-separated)")
+	webhookCreateCmd.Flags().String("content-type", "application/json", "Content type (application/json or application/x-www-form-urlencoded)")
+	webhookCreateCmd.Flags().String("secret", "", "HMAC secret used to sign payloads")
+	webhookCreateCmd.Flags().String("branch-filter", "", "Glob filter for branches that trigger the hook")
+	webhookCreateCmd.Flags().String("authorization-header", "", "Authorization header value sent with each delivery")
+	webhookCreateCmd.Flags().Bool("active", true, "Whether the hook is active on creation")
+
+	addRepoFlags(webhookUpdateCmd)
+	webhookUpdateCmd.Flags().String("url", "", "New target URL")
+	webhookUpdateCmd.Flags().StringSlice("events", nil, "New event list (replaces existing)")
+	webhookUpdateCmd.Flags().String("content-type", "", "New content type")
+	webhookUpdateCmd.Flags().String("secret", "", "New HMAC secret")
+	webhookUpdateCmd.Flags().String("branch-filter", "", "New branch filter")
+	webhookUpdateCmd.Flags().String("authorization-header", "", "New authorization header")
+	webhookUpdateCmd.Flags().Bool("active", true, "Enable or disable the hook")
+
+	addRepoFlags(webhookDeleteCmd)
+	webhookDeleteCmd.Flags().BoolP("yes", "y", false, "Skip confirmation prompt")
+}
+
+func runWebhookList(cmd *cobra.Command, args []string) error {
+	client, owner, name, err := newWebhookClient(cmd)
+	if err != nil {
+		return err
+	}
+
+	hooks, _, err := client.ListRepoHooks(owner, name, gitea.ListHooksOptions{})
+	if err != nil {
+		return fmt.Errorf("failed to list webhooks: %w", err)
+	}
+
+	if wantJSON(cmd) {
+		return outputJSON(cmd, hooks)
+	}
+
+	if len(hooks) == 0 {
+		fmt.Fprintln(ios.Out, "No webhooks.")
+		return nil
+	}
+
+	tp := ios.NewTablePrinter()
+	tp.AddHeader("ID", "TYPE", "URL", "EVENTS", "ACTIVE")
+	for _, h := range hooks {
+		url := h.Config["url"]
+		active := "no"
+		if h.Active {
+			active = "yes"
+		}
+		tp.AddRow(
+			strconv.FormatInt(h.ID, 10),
+			h.Type,
+			url,
+			strings.Join(h.Events, ","),
+			active,
+		)
+	}
+	return tp.Render()
+}
+
+func runWebhookCreate(cmd *cobra.Command, args []string) error {
+	client, owner, name, err := newWebhookClient(cmd)
+	if err != nil {
+		return err
+	}
+
+	url := args[0]
+	hookType, _ := cmd.Flags().GetString("type")
+	events, _ := cmd.Flags().GetStringSlice("events")
+	contentType, _ := cmd.Flags().GetString("content-type")
+	secret, _ := cmd.Flags().GetString("secret")
+	branchFilter, _ := cmd.Flags().GetString("branch-filter")
+	authHeader, _ := cmd.Flags().GetString("authorization-header")
+	active, _ := cmd.Flags().GetBool("active")
+
+	opt := gitea.CreateHookOption{
+		Type: gitea.HookType(hookType),
+		Config: map[string]string{
+			"url":          url,
+			"content_type": contentType,
+		},
+		Events:              events,
+		BranchFilter:        branchFilter,
+		Active:              active,
+		AuthorizationHeader: authHeader,
+	}
+	if secret != "" {
+		opt.Config["secret"] = secret
+	}
+
+	hook, _, err := client.CreateRepoHook(owner, name, opt)
+	if err != nil {
+		return fmt.Errorf("failed to create webhook: %w", err)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Created webhook %d (%s → %s)\n", cs.SuccessIcon(), hook.ID, hook.Type, url)
+	return nil
+}
+
+func runWebhookUpdate(cmd *cobra.Command, args []string) error {
+	client, owner, name, err := newWebhookClient(cmd)
+	if err != nil {
+		return err
+	}
+
+	id, err := strconv.ParseInt(args[0], 10, 64)
+	if err != nil {
+		return fmt.Errorf("invalid webhook id %q: %w", args[0], err)
+	}
+
+	opt := gitea.EditHookOption{}
+
+	// Only set fields the user explicitly provided.
+	cfg := map[string]string{}
+	if url, _ := cmd.Flags().GetString("url"); url != "" {
+		cfg["url"] = url
+	}
+	if ct, _ := cmd.Flags().GetString("content-type"); ct != "" {
+		cfg["content_type"] = ct
+	}
+	if secret, _ := cmd.Flags().GetString("secret"); secret != "" {
+		cfg["secret"] = secret
+	}
+	if len(cfg) > 0 {
+		opt.Config = cfg
+	}
+
+	if cmd.Flags().Changed("events") {
+		events, _ := cmd.Flags().GetStringSlice("events")
+		opt.Events = events
+	}
+	if cmd.Flags().Changed("branch-filter") {
+		bf, _ := cmd.Flags().GetString("branch-filter")
+		opt.BranchFilter = bf
+	}
+	if cmd.Flags().Changed("authorization-header") {
+		auth, _ := cmd.Flags().GetString("authorization-header")
+		opt.AuthorizationHeader = auth
+	}
+	if cmd.Flags().Changed("active") {
+		active, _ := cmd.Flags().GetBool("active")
+		opt.Active = &active
+	}
+
+	if _, err := client.EditRepoHook(owner, name, id, opt); err != nil {
+		return fmt.Errorf("failed to update webhook %d: %w", id, err)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Updated webhook %d\n", cs.SuccessIcon(), id)
+	return nil
+}
+
+func runWebhookDelete(cmd *cobra.Command, args []string) error {
+	client, owner, name, err := newWebhookClient(cmd)
+	if err != nil {
+		return err
+	}
+
+	id, err := strconv.ParseInt(args[0], 10, 64)
+	if err != nil {
+		return fmt.Errorf("invalid webhook id %q: %w", args[0], err)
+	}
+
+	skipConfirm, _ := cmd.Flags().GetBool("yes")
+	if !skipConfirm && ios.IsStdinTTY() {
+		answer, err := promptLine(fmt.Sprintf("Delete webhook %d in %s/%s? [y/N]: ", id, owner, name))
+		if err != nil {
+			return err
+		}
+		if answer != "y" && answer != "Y" && answer != "yes" {
+			fmt.Fprintln(ios.ErrOut, "Cancelled.")
+			return nil
+		}
+	}
+
+	if _, err := client.DeleteRepoHook(owner, name, id); err != nil {
+		return fmt.Errorf("failed to delete webhook %d: %w", id, err)
+	}
+
+	cs := ios.ColorScheme()
+	fmt.Fprintf(ios.Out, "%s Deleted webhook %d\n", cs.SuccessIcon(), id)
+	return nil
+}
+
+func newWebhookClient(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
+}
diff --git a/cmd/whoami.go b/cmd/whoami.go
new file mode 100644
index 0000000..9955eb8
--- /dev/null
+++ b/cmd/whoami.go
@@ -0,0 +1,53 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+)
+
+var whoamiCmd = &cobra.Command{
+	Use:   "whoami",
+	Short: "Show the authenticated user on the current host",
+	Long:  "Display login, full name, and email for the authenticated user on the active host.",
+	Example: `  # Show who you are on the active host
+  fgj whoami
+
+  # On a specific host
+  fgj whoami --hostname forgejo.example.com
+
+  # As JSON
+  fgj whoami --json`,
+	RunE: runWhoami,
+}
+
+func init() {
+	rootCmd.AddCommand(whoamiCmd)
+	addJSONFlags(whoamiCmd, "Output as JSON")
+}
+
+func runWhoami(cmd *cobra.Command, args []string) error {
+	client, err := loadClient()
+	if err != nil {
+		return err
+	}
+
+	user, _, err := client.GetMyUserInfo()
+	if err != nil {
+		return fmt.Errorf("failed to fetch current user: %w", err)
+	}
+
+	if wantJSON(cmd) {
+		return outputJSON(cmd, user)
+	}
+
+	fmt.Fprintf(ios.Out, "%s\n", user.UserName)
+	if user.FullName != "" && user.FullName != user.UserName {
+		fmt.Fprintf(ios.Out, "  name:  %s\n", user.FullName)
+	}
+	if user.Email != "" {
+		fmt.Fprintf(ios.Out, "  email: %s\n", user.Email)
+	}
+	fmt.Fprintf(ios.Out, "  host:  %s\n", client.Hostname())
+	return nil
+}
diff --git a/cmd/wiki.go b/cmd/wiki.go
index 63cb504..36e2ce5 100644
--- a/cmd/wiki.go
+++ b/cmd/wiki.go
@@ -7,9 +7,9 @@ import (
 	"net/url"
 	"time"
 
-	"forgejo.zerova.net/public/fj/internal/api"
-	"forgejo.zerova.net/public/fj/internal/config"
-	"forgejo.zerova.net/public/fj/internal/text"
+	"forgejo.zerova.net/public/fgj-sid/internal/api"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
+	"forgejo.zerova.net/public/fgj-sid/internal/text"
 	"github.com/spf13/cobra"
 )
 
@@ -61,13 +61,13 @@ var wikiListCmd = &cobra.Command{
 	Short: "List wiki pages",
 	Long:  "List all wiki pages for a repository.",
 	Example: `  # List wiki pages for the current repo
-  fj wiki list
+  fgj wiki list
 
   # List wiki pages for a specific repo
-  fj wiki list -R owner/repo
+  fgj wiki list -R owner/repo
 
   # Output as JSON
-  fj wiki list --json`,
+  fgj wiki list --json`,
 	RunE: runWikiList,
 }
 
@@ -76,16 +76,16 @@ var wikiViewCmd = &cobra.Command{
 	Short: "View a wiki page",
 	Long:  "Display the content of a wiki page.",
 	Example: `  # View a wiki page
-  fj wiki view Home
+  fgj wiki view Home
 
   # Open in browser
-  fj wiki view Home --web
+  fgj wiki view Home --web
 
   # View a wiki page as JSON (includes content)
-  fj wiki view Home --json
+  fgj wiki view Home --json
 
   # View a wiki page from a specific repo
-  fj wiki view "Getting-Started" -R owner/repo`,
+  fgj wiki view "Getting-Started" -R owner/repo`,
 	Args: cobra.ExactArgs(1),
 	RunE: runWikiView,
 }
@@ -95,16 +95,16 @@ var wikiCreateCmd = &cobra.Command{
 	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."
+  fgj 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
+  fgj wiki create "Setup Guide" --body-file setup.md
 
   # Create a wiki page from stdin
-  echo "# FAQ" | fj wiki create FAQ --body-file -
+  echo "# FAQ" | fgj wiki create FAQ --body-file -
 
   # Output as JSON
-  fj wiki create "New Page" -b "Content here" --json`,
+  fgj wiki create "New Page" -b "Content here" --json`,
 	Args: cobra.ExactArgs(1),
 	RunE: runWikiCreate,
 }
@@ -114,16 +114,16 @@ var wikiEditCmd = &cobra.Command{
 	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."
+  fgj 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
+  fgj 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 -
+  cat new-content.md | fgj wiki edit Home --body-file -
 
   # Output as JSON
-  fj wiki edit Home -b "Updated content" --json`,
+  fgj wiki edit Home -b "Updated content" --json`,
 	Args: cobra.ExactArgs(1),
 	RunE: runWikiEdit,
 }
@@ -133,13 +133,13 @@ var wikiDeleteCmd = &cobra.Command{
 	Short: "Delete a wiki page",
 	Long:  "Delete a wiki page from the repository.",
 	Example: `  # Delete a wiki page
-  fj wiki delete "Old Page"
+  fgj wiki delete "Old Page"
 
   # Delete without confirmation
-  fj wiki delete "Old Page" -y
+  fgj wiki delete "Old Page" -y
 
   # Delete a wiki page from a specific repo
-  fj wiki delete "Outdated Guide" -R owner/repo`,
+  fgj wiki delete "Outdated Guide" -R owner/repo`,
 	Args: cobra.ExactArgs(1),
 	RunE: runWikiDelete,
 }
@@ -266,9 +266,10 @@ func runWikiView(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("wiki page has no HTML URL")
 	}
 
-	if wantJSON(cmd) {
+	jsonFlag, _ := cmd.Flags().GetBool("json")
+	if jsonFlag {
 		page.Content = string(content)
-		return outputJSON(cmd, page)
+		return writeJSON(page)
 	}
 
 	if err := ios.StartPager(); err != nil {
diff --git a/go.mod b/go.mod
index 1c216be..d6f219e 100644
--- a/go.mod
+++ b/go.mod
@@ -1,9 +1,10 @@
-module forgejo.zerova.net/public/fj
+module forgejo.zerova.net/public/fgj-sid
 
 go 1.24.0
 
 require (
-	code.gitea.io/sdk/gitea v0.22.1
+	code.gitea.io/sdk/gitea v0.23.2
+	github.com/itchyny/gojq v0.12.18
 	github.com/spf13/cobra v1.8.1
 	github.com/spf13/viper v1.19.0
 	golang.org/x/term v0.32.0
@@ -19,7 +20,6 @@ require (
 	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
diff --git a/go.sum b/go.sum
index 7618c0c..58b29ed 100644
--- a/go.sum
+++ b/go.sum
@@ -1,5 +1,5 @@
-code.gitea.io/sdk/gitea v0.22.1 h1:7K05KjRORyTcTYULQ/AwvlVS6pawLcWyXZcTr7gHFyA=
-code.gitea.io/sdk/gitea v0.22.1/go.mod h1:yyF5+GhljqvA30sRDreoyHILruNiy4ASufugzYg0VHM=
+code.gitea.io/sdk/gitea v0.23.2 h1:iJB1FDmLegwfwjX8gotBDHdPSbk/ZR8V9VmEJaVsJYg=
+code.gitea.io/sdk/gitea v0.23.2/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=
@@ -90,8 +90,6 @@ golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 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=
diff --git a/internal/api/client.go b/internal/api/client.go
index 0666357..282a86a 100644
--- a/internal/api/client.go
+++ b/internal/api/client.go
@@ -9,19 +9,13 @@ import (
 	"time"
 
 	"code.gitea.io/sdk/gitea"
-	"forgejo.zerova.net/public/fj/internal/config"
+	"forgejo.zerova.net/public/fgj-sid/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{
+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
diff --git a/internal/api/client_test.go b/internal/api/client_test.go
index 2dba74c..5b26675 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"
+	"forgejo.zerova.net/public/fgj-sid/internal/config"
 )
 
 func TestClient_Hostname(t *testing.T) {
diff --git a/internal/config/config.go b/internal/config/config.go
index 79c5c0b..f326613 100644
--- a/internal/config/config.go
+++ b/internal/config/config.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"sort"
 	"strings"
 
 	"github.com/spf13/viper"
@@ -14,41 +15,28 @@ 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"`
+	Default     bool     `yaml:"default,omitempty"`
 	Order       int      `yaml:"-"` // config file order, set at load time
 }
 
 func GetConfigDir() (string, error) {
 	if xdgConfigHome := os.Getenv("XDG_CONFIG_HOME"); xdgConfigHome != "" {
-		return filepath.Join(xdgConfigHome, "fj"), nil
+		return filepath.Join(xdgConfigHome, "fgj"), 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
@@ -145,17 +133,18 @@ func (c *Config) SaveToPath(path string) error {
 // Priority order:
 // 1. Explicitly provided hostname parameter
 // 2. CLI flag (--hostname)
-// 3. Environment variable (FJ_HOST, with FGJ_HOST fallback)
+// 3. Environment variable (FGJ_HOST)
 // 4. Auto-detected hostname from git remote
 // 5. match_dirs lookup (longest prefix match)
-// 6. Default to codeberg.org
+// 6. Configured default host (HostConfig.Default == true)
+// 7. Default to codeberg.org
 func (c *Config) GetHost(hostname string, detectedHost string, cwd string) (HostConfig, error) {
 	if hostname == "" {
 		hostname = viper.GetString("hostname")
 	}
 
 	if hostname == "" {
-		hostname = EnvWithFallback("FJ_HOST", "FGJ_HOST")
+		hostname = os.Getenv("FGJ_HOST")
 	}
 
 	if hostname == "" {
@@ -166,6 +155,10 @@ func (c *Config) GetHost(hostname string, detectedHost string, cwd string) (Host
 		hostname = c.ResolveHostByPath(cwd)
 	}
 
+	if hostname == "" {
+		hostname = c.DefaultHost()
+	}
+
 	if hostname == "" {
 		hostname = "codeberg.org"
 	}
@@ -178,6 +171,27 @@ func (c *Config) GetHost(hostname string, detectedHost string, cwd string) (Host
 	return host, nil
 }
 
+// DefaultHost returns the hostname of the host marked Default == true.
+// If no host is marked default, returns "". If multiple hosts are marked
+// default (a user-error case), the one that sorts first alphabetically is
+// returned and a warning is printed to stderr.
+func (c *Config) DefaultHost() string {
+	var matches []string
+	for hostname, host := range c.Hosts {
+		if host.Default {
+			matches = append(matches, hostname)
+		}
+	}
+	if len(matches) == 0 {
+		return ""
+	}
+	sort.Strings(matches)
+	if len(matches) > 1 {
+		fmt.Fprintf(os.Stderr, "warning: multiple hosts marked default (%s); using %s\n", strings.Join(matches, ", "), matches[0])
+	}
+	return matches[0]
+}
+
 // 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
@@ -242,15 +256,6 @@ func (c *Config) ResolveHostByPath(cwd string) string {
 }
 
 // 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()
diff --git a/internal/config/config_test.go b/internal/config/config_test.go
index 4300e45..8ceae65 100644
--- a/internal/config/config_test.go
+++ b/internal/config/config_test.go
@@ -83,7 +83,7 @@ func TestGetConfigDir_XDG(t *testing.T) {
 		t.Fatalf("Unexpected error: %v", err)
 	}
 
-	expected := "/custom/config/fj"
+	expected := "/custom/config/fgj"
 	if dir != expected {
 		t.Errorf("Expected %q, got %q", expected, dir)
 	}
@@ -439,7 +439,7 @@ func TestResolveHostByPath(t *testing.T) {
 			"forgejo.zerova.net": {
 				Hostname:  "forgejo.zerova.net",
 				Token:     "token1",
-				MatchDirs: []string{"/Users/sid/repos/fj", "/Users/sid/repos/zerova"},
+				MatchDirs: []string{"/Users/sid/repos/fgj", "/Users/sid/repos/zerova"},
 			},
 			"codeberg.org": {
 				Hostname:  "codeberg.org",
@@ -459,10 +459,10 @@ func TestResolveHostByPath(t *testing.T) {
 		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"},
+		{"exact dir match", "/Users/sid/repos/fgj", "forgejo.zerova.net"},
+		{"nested dir match", "/Users/sid/repos/fgj/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"},
+		{"longest prefix wins over /", "/Users/sid/repos/fgj/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"},
@@ -512,7 +512,7 @@ func TestGetHost_MatchDirsIntegration(t *testing.T) {
 			"forgejo.zerova.net": {
 				Hostname:  "forgejo.zerova.net",
 				Token:     "token1",
-				MatchDirs: []string{"/Users/sid/repos/fj"},
+				MatchDirs: []string{"/Users/sid/repos/fgj"},
 			},
 			"codeberg.org": {
 				Hostname: "codeberg.org",
@@ -522,7 +522,7 @@ func TestGetHost_MatchDirsIntegration(t *testing.T) {
 	}
 
 	// cwd match should resolve to forgejo.zerova.net
-	host, err := cfg.GetHost("", "", "/Users/sid/repos/fj/cmd")
+	host, err := cfg.GetHost("", "", "/Users/sid/repos/fgj/cmd")
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
diff --git a/internal/git/git_test.go b/internal/git/git_test.go
index a00f4af..76d8764 100644
--- a/internal/git/git_test.go
+++ b/internal/git/git_test.go
@@ -17,41 +17,41 @@ func TestParseRemoteURL(t *testing.T) {
 	}{
 		{
 			name:      "HTTPS URL with .git",
-			url:       "https://codeberg.org/romaintb/fj.git",
+			url:       "https://codeberg.org/romaintb/fgj.git",
 			wantOwner: "romaintb",
-			wantName:  "fj",
+			wantName:  "fgj",
 			wantHost:  "codeberg.org",
 			wantErr:   false,
 		},
 		{
 			name:      "HTTPS URL without .git",
-			url:       "https://codeberg.org/romaintb/fj",
+			url:       "https://codeberg.org/romaintb/fgj",
 			wantOwner: "romaintb",
-			wantName:  "fj",
+			wantName:  "fgj",
 			wantHost:  "codeberg.org",
 			wantErr:   false,
 		},
 		{
 			name:      "SSH URL with .git",
-			url:       "git@codeberg.org:romaintb/fj.git",
+			url:       "git@codeberg.org:romaintb/fgj.git",
 			wantOwner: "romaintb",
-			wantName:  "fj",
+			wantName:  "fgj",
 			wantHost:  "codeberg.org",
 			wantErr:   false,
 		},
 		{
 			name:      "SSH URL without .git",
-			url:       "git@codeberg.org:romaintb/fj",
+			url:       "git@codeberg.org:romaintb/fgj",
 			wantOwner: "romaintb",
-			wantName:  "fj",
+			wantName:  "fgj",
 			wantHost:  "codeberg.org",
 			wantErr:   false,
 		},
 		{
 			name:      "SSH protocol URL",
-			url:       "ssh://git@codeberg.org/romaintb/fj.git",
+			url:       "ssh://git@codeberg.org/romaintb/fgj.git",
 			wantOwner: "romaintb",
-			wantName:  "fj",
+			wantName:  "fgj",
 			wantHost:  "codeberg.org",
 			wantErr:   false,
 		},
diff --git a/internal/iostreams/iostreams.go b/internal/iostreams/iostreams.go
index 8e6528b..88561ad 100644
--- a/internal/iostreams/iostreams.go
+++ b/internal/iostreams/iostreams.go
@@ -37,10 +37,10 @@ type IOStreams 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.
+// with TTY status auto-detected. Setting 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") != ""
+	forceTTY := os.Getenv("FGJ_FORCE_TTY") != ""
 
 	stdinTTY := forceTTY || (isTerminal(os.Stdin.Fd()))
 	stdoutTTY := forceTTY || (isTerminal(os.Stdout.Fd()))
@@ -118,17 +118,14 @@ func (s *IOStreams) ColorScheme() *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.
+// It checks 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")
-	}
+	pagerCmd := os.Getenv("FGJ_PAGER")
 	if pagerCmd == "" {
 		pagerCmd = os.Getenv("PAGER")
 	}
diff --git a/main.go b/main.go
index 1c4f378..f23476d 100644
--- a/main.go
+++ b/main.go
@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"os"
 
-	"forgejo.zerova.net/public/fj/cmd"
+	"forgejo.zerova.net/public/fgj-sid/cmd"
 )
 
 func main() {
diff --git a/tests/functional/fixtures.go b/tests/functional/fixtures.go
index ec6b72d..6bf9733 100644
--- a/tests/functional/fixtures.go
+++ b/tests/functional/fixtures.go
@@ -228,18 +228,15 @@ func (env *TestEnv) CleanupRepo(owner, repoName string) {
 	}
 }
 
-// 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 +248,7 @@ func (env *TestEnv) GetBinaryPath() string {
 			}
 		}
 		// If no binary found, return default (will error when executed)
-		binaryPath = "./bin/fj"
+		binaryPath = "./bin/fgj"
 	}
 	return binaryPath
 }
diff --git a/tests/functional/functional_test.go b/tests/functional/functional_test.go
index 740cde3..7202bb5 100644
--- a/tests/functional/functional_test.go
+++ b/tests/functional/functional_test.go
@@ -86,7 +86,7 @@ func TestCLIIssueList(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")
+	issueNum := env.CreateTestIssue("[FGJ E2E Test] Issue List", "For issue list test")
 	defer env.CleanupIssue(issueNum)
 
 	result := env.RunCLI(
@@ -109,7 +109,7 @@ func TestCLIIssueList(t *testing.T) {
 func TestCLIIssueListJSON(t *testing.T) {
 	env := NewTestEnv(t)
 
-	issueNum := env.CreateTestIssue("[FJ E2E Test] JSON List", "For JSON output test")
+	issueNum := env.CreateTestIssue("[FGJ E2E Test] JSON List", "For JSON output test")
 	defer env.CleanupIssue(issueNum)
 
 	result := env.RunCLI(
@@ -137,7 +137,7 @@ func TestCLIIssueListJSON(t *testing.T) {
 func TestCLIIssueView(t *testing.T) {
 	env := NewTestEnv(t)
 
-	issueNum := env.CreateTestIssue("[FJ E2E Test] View Test", "Testing issue view")
+	issueNum := env.CreateTestIssue("[FGJ E2E Test] View Test", "Testing issue view")
 	defer env.CleanupIssue(issueNum)
 
 	result := env.RunCLI(
@@ -160,7 +160,7 @@ func TestCLIIssueView(t *testing.T) {
 func TestCLIIssueViewJSON(t *testing.T) {
 	env := NewTestEnv(t)
 
-	issueNum := env.CreateTestIssue("[FJ E2E Test] JSON View", "Testing JSON view")
+	issueNum := env.CreateTestIssue("[FGJ E2E Test] JSON View", "Testing JSON view")
 	defer env.CleanupIssue(issueNum)
 
 	result := env.RunCLI(
@@ -198,8 +198,8 @@ func TestCLIIssueCreate(t *testing.T) {
 		"--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",
+		"-t", "[FGJ E2E Test] CLI Created Issue",
+		"-b", "Created directly via fgj CLI",
 	)
 
 	if result.ExitCode != 0 {
@@ -229,7 +229,7 @@ func TestCLIIssueCreateWithLabels(t *testing.T) {
 		"--hostname", env.Hostname,
 		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
 		"issue", "create",
-		"-t", "[FJ E2E Test] Issue with Labels",
+		"-t", "[FGJ E2E Test] Issue with Labels",
 		"-b", "This issue was created with labels",
 		"-l", "bug",
 		"-l", "enhancement",
@@ -275,7 +275,7 @@ func TestCLIIssueCreateWithLabels(t *testing.T) {
 func TestCLIIssueComment(t *testing.T) {
 	env := NewTestEnv(t)
 
-	issueNum := env.CreateTestIssue("[FJ E2E Test] Comment Test", "Testing comment via CLI")
+	issueNum := env.CreateTestIssue("[FGJ E2E Test] Comment Test", "Testing comment via CLI")
 	defer env.CleanupIssue(issueNum)
 
 	result := env.RunCLI(
@@ -313,7 +313,7 @@ func TestCLIIssueComment(t *testing.T) {
 func TestCLIIssueClose(t *testing.T) {
 	env := NewTestEnv(t)
 
-	issueNum := env.CreateTestIssue("[FJ E2E Test] Close Test", "Will be closed via CLI")
+	issueNum := env.CreateTestIssue("[FGJ E2E Test] Close Test", "Will be closed via CLI")
 
 	result := env.RunCLI(
 		"--hostname", env.Hostname,
@@ -341,7 +341,7 @@ func TestCLIIssueClose(t *testing.T) {
 func TestCLIIssueCloseWithComment(t *testing.T) {
 	env := NewTestEnv(t)
 
-	issueNum := env.CreateTestIssue("[FJ E2E Test] Close with comment", "Will be closed with a comment")
+	issueNum := env.CreateTestIssue("[FGJ E2E Test] Close with comment", "Will be closed with a comment")
 
 	commentText := "Fixed in v2.0 - closing via functional test"
 
@@ -389,7 +389,7 @@ func TestCLIIssueCloseWithComment(t *testing.T) {
 func TestCLIIssueEditTitle(t *testing.T) {
 	env := NewTestEnv(t)
 
-	issueNum := env.CreateTestIssue("[FJ E2E Test] Original Title", "Will be edited")
+	issueNum := env.CreateTestIssue("[FGJ E2E Test] Original Title", "Will be edited")
 	defer env.CleanupIssue(issueNum)
 
 	result := env.RunCLI(
@@ -397,7 +397,7 @@ func TestCLIIssueEditTitle(t *testing.T) {
 		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
 		"issue", "edit",
 		fmt.Sprintf("%d", issueNum),
-		"-t", "[FJ E2E Test] Updated Title",
+		"-t", "[FGJ E2E Test] Updated Title",
 	)
 
 	if result.ExitCode != 0 {
@@ -409,7 +409,7 @@ func TestCLIIssueEditTitle(t *testing.T) {
 		t.Fatalf("failed to get issue: %v", err)
 	}
 
-	if issue.Title != "[FJ E2E Test] Updated Title" {
+	if issue.Title != "[FGJ E2E Test] Updated Title" {
 		t.Fatalf("expected updated title, got '%s'", issue.Title)
 	}
 
@@ -421,7 +421,7 @@ func TestCLIIssueEditAddLabels(t *testing.T) {
 
 	env.EnsureTestLabels()
 
-	issueNum := env.CreateTestIssue("[FJ E2E Test] Add Labels", "Will have labels added")
+	issueNum := env.CreateTestIssue("[FGJ E2E Test] Add Labels", "Will have labels added")
 	defer env.CleanupIssue(issueNum)
 
 	result := env.RunCLI(
@@ -464,7 +464,7 @@ func TestCLIIssueEditRemoveLabels(t *testing.T) {
 	env.EnsureTestLabels()
 
 	issue, _, err := env.Client.CreateIssue(env.Owner, env.RepoName, gitea.CreateIssueOption{
-		Title: "[FJ E2E Test] Remove Labels",
+		Title: "[FGJ E2E Test] Remove Labels",
 		Body:  "Will have labels removed",
 	})
 	if err != nil {
@@ -616,7 +616,7 @@ 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")
+	issueNum := env.CreateTestIssue("[FGJ E2E Test] PR Comment Test", "Testing pr comment command")
 	defer env.CleanupIssue(issueNum)
 
 	result := env.RunCLI(
@@ -624,14 +624,14 @@ func TestCLIPRComment(t *testing.T) {
 		"-R", fmt.Sprintf("%s/%s", env.Owner, env.RepoName),
 		"pr", "comment",
 		fmt.Sprintf("%d", issueNum),
-		"-b", "Automated test comment via fj pr comment",
+		"-b", "Automated test comment via fgj 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)
+	t.Logf("Successfully commented on issue #%d via fgj pr comment", issueNum)
 }
 
 // ===== CLI Repo Commands =====
@@ -678,14 +678,14 @@ func TestCLIRepoList(t *testing.T) {
 func TestCLIRepoCreate(t *testing.T) {
 	env := NewTestEnv(t)
 
-	repoName := fmt.Sprintf("fj-test-create-%d", time.Now().UnixNano())
+	repoName := fmt.Sprintf("fgj-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",
+		"-d", "Created by fgj functional test",
 	)
 
 	if result.ExitCode != 0 {
@@ -703,8 +703,8 @@ func TestCLIRepoCreate(t *testing.T) {
 	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)
+	if repo.Description != "Created by fgj functional test" {
+		t.Fatalf("expected description %q, got %q", "Created by fgj functional test", repo.Description)
 	}
 
 	t.Logf("Successfully created repository %s via CLI", repo.FullName)
@@ -756,7 +756,7 @@ func TestCLIRepoClone(t *testing.T) {
 	env := NewTestEnv(t)
 
 	tmpDir := t.TempDir()
-	clonePath := fmt.Sprintf("%s/fj-clone", tmpDir)
+	clonePath := fmt.Sprintf("%s/fgj-clone", tmpDir)
 
 	result := env.RunCLI(
 		"--hostname", env.Hostname,
@@ -799,13 +799,13 @@ func TestCLIReleaseList(t *testing.T) {
 func TestCLIReleaseCreateUploadDelete(t *testing.T) {
 	env := NewTestEnv(t)
 
-	tag := fmt.Sprintf("fj-test-%d", time.Now().UnixNano())
-	title := "FJ CLI Release Test"
+	tag := fmt.Sprintf("fgj-test-%d", time.Now().UnixNano())
+	title := "FGJ 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 {
+	if err := os.WriteFile(assetPath, []byte("fgj release asset"), 0600); err != nil {
 		t.Fatalf("failed to create asset file: %v", err)
 	}
 
@@ -863,7 +863,7 @@ func TestCLIReleaseView(t *testing.T) {
 	env := NewTestEnv(t)
 
 	// Create a release to view
-	tag := fmt.Sprintf("fj-view-test-%d", time.Now().UnixNano())
+	tag := fmt.Sprintf("fgj-view-test-%d", time.Now().UnixNano())
 
 	createResult := env.RunCLI(
 		"--hostname", env.Hostname,
@@ -1149,7 +1149,7 @@ func TestCLIAPIGet(t *testing.T) {
 		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")
+	t.Logf("Successfully retrieved repo info via fgj api GET")
 }
 
 func TestCLIAPIPostAndDelete(t *testing.T) {
@@ -1161,8 +1161,8 @@ func TestCLIAPIPostAndDelete(t *testing.T) {
 		"--hostname", env.Hostname,
 		"api", endpoint,
 		"-X", "POST",
-		"-f", "title=[FJ E2E Test] API Post Test",
-		"-f", "body=Created via fj api command",
+		"-f", "title=[FGJ E2E Test] API Post Test",
+		"-f", "body=Created via fgj api command",
 	)
 
 	if result.ExitCode != 0 {
@@ -1182,7 +1182,7 @@ func TestCLIAPIPostAndDelete(t *testing.T) {
 	issueNum := int64(issueNumber)
 	defer env.CleanupIssue(issueNum)
 
-	t.Logf("Successfully created issue #%d via fj api POST", issueNum)
+	t.Logf("Successfully created issue #%d via fgj api POST", issueNum)
 }
 
 // ===== Structured Error Output =====