@cluesmith/codev 3.3.1 → 3.3.3

package/scripts/forge/gitea/pr-create.sh

@@ -0,0 +1,155 @@
+#!/bin/sh
+# Forge concept: pr-create (Gitea/Forgejo via tea CLI)
+# forge-executable: tea
+#
+# Input:  CODEV_PR_TITLE (required)
+#         CODEV_PR_BODY  (required, may be empty)
+#         CODEV_PR_BASE, CODEV_PR_HEAD, CODEV_PR_REPO, CODEV_PR_DRAFT (optional)
+#         CODEV_PR_LOGIN (optional, gitea-only: tea's --login, for multi-login hosts)
+# Output: {"number": <int>, "url": "<web url>"}
+#
+# Creates the PR with the raw REST passthrough (`tea api -X POST …/pulls`),
+# which RETURNS THE CREATED PR — number and `html_url` — in its response body.
+# There is no lookup afterwards, so there is nothing to race and nothing to
+# paginate.
+#
+# Why not `tea pulls create`: it prints a rendered, line-wrapped, ANSI-decorated
+# view of the new PR rather than anything parseable, so it has to be followed by
+# a search for the PR it just made. That search was the bug. #1146 established
+# that Gitea caps every list response at the server's `max_response_items`
+# (default 50 — confirmed against Forgejo 15.0.2: `settings/api` reports 50, and
+# a `?limit=200` request returns exactly 50 items where paging at 50 returns 53),
+# so `tea pulls list --limit 200` silently truncates. On a busy repo the
+# just-created PR falls off the first page and this script would have reported
+# failure for a PR that exists — inviting a duplicate retry.
+#
+# Verified against tea 0.14.2 + Forgejo 15.0.2:
+#   - POST repos/{owner}/{repo}/pulls returns the full PR object, incl. `number`
+#     and `html_url` (its `url` is the browser page too on create, unlike the GET
+#     shape where `url` is the API endpoint — hence `.html_url // .url`).
+#   - `{owner}`/`{repo}` are substituted by tea from the repo context, and
+#     `--repo <owner>/<name>` supplies that context when the cwd has no Gitea
+#     remote. Verified with https and scp-style Gitea remotes.
+#   - `base` is REQUIRED by the API (it answers `[Base]: Required` without it),
+#     unlike `tea pulls create`, which defaults it client-side. So when
+#     CODEV_PR_BASE is unset this resolves the repo's default branch first.
+#   - `draft: true` in the payload is SILENTLY IGNORED (the response comes back
+#     `draft: false`). Gitea marks a PR draft by a `WIP:` title prefix, which is
+#     exactly what `tea pulls create --draft` does, so that is replicated here.
+#   - `tea api` EXITS 0 on HTTP errors, printing the error body (JSON with
+#     `.message`, or bare text like `404 page not found`). Failure therefore has
+#     to be detected by inspecting the response, never by exit status — see the
+#     assertion below, which is the load-bearing check in this script.
+set -e
+
+if [ -z "$CODEV_PR_TITLE" ]; then
+  echo "pr-create: CODEV_PR_TITLE is required" >&2
+  exit 2
+fi
+
+# An empty body is allowed; an *absent* one is not. Without this, forgetting the
+# variable opens a PR with no body at exit 0 — the silent failure #1455 is about.
+if [ -z "${CODEV_PR_BODY+x}" ]; then
+  echo "pr-create: CODEV_PR_BODY is required (set it to \"\" for an empty body)" >&2
+  exit 2
+fi
+
+head=$CODEV_PR_HEAD
+if [ -z "$head" ]; then
+  head=$(git rev-parse --abbrev-ref HEAD)
+fi
+
+# Gitea has no draft flag on the API; a "WIP:" title prefix is the draft marker.
+title=$CODEV_PR_TITLE
+if [ "$CODEV_PR_DRAFT" = "1" ]; then
+  title="WIP: $CODEV_PR_TITLE"
+fi
+
+# Shared tea options: which host/repo to talk to. `{owner}`/`{repo}` in the
+# endpoint are filled from this context.
+set --
+if [ -n "$CODEV_PR_REPO" ]; then set -- "$@" --repo "$CODEV_PR_REPO"; fi
+if [ -n "$CODEV_PR_LOGIN" ]; then set -- "$@" --login "$CODEV_PR_LOGIN"; fi
+
+base=$CODEV_PR_BASE
+if [ -z "$base" ]; then
+  # The API rejects a missing base, so mirror `tea pulls create`'s default.
+  base_response=$(tea api "$@" 'repos/{owner}/{repo}') || base_response=
+  base=$(printf '%s' "$base_response" | jq -r '.default_branch // empty' 2>/dev/null) || base=
+  if [ -z "$base" ]; then
+    # An unresolvable repo (404 — same cause as the POST path below) means the
+    # actual remedy is CODEV_PR_REPO, not CODEV_PR_BASE; only a resolvable repo
+    # with a genuinely missing default_branch calls for CODEV_PR_BASE.
+    case "$base_response" in
+      404*)
+        echo "pr-create: Gitea answered 404 — could not resolve owner/repo for this repository." >&2
+        echo "pr-create: set CODEV_PR_REPO=owner/repo, or run from a checkout whose remote is a configured Gitea host." >&2
+        ;;
+      *)
+        echo "pr-create: could not resolve the repository's default branch; set CODEV_PR_BASE" >&2
+        ;;
+    esac
+    exit 1
+  fi
+fi
+
+# Build the payload with jq so an arbitrary body — quotes, backticks, newlines,
+# backslashes, unicode — is JSON-escaped rather than interpolated, and feed it
+# on stdin (`-d @-`) so it never has to survive an argv round-trip.
+response=$(
+  jq -n --arg title "$title" --arg body "$CODEV_PR_BODY" \
+        --arg head "$head" --arg base "$base" \
+        '{title: $title, body: $body, head: $head, base: $base}' \
+    | tea api "$@" -X POST -d @- 'repos/{owner}/{repo}/pulls'
+)
+
+# `tea api` exits 0 on HTTP errors, so the response body is the ONLY signal that
+# the PR was created. Trusting the exit code here would reintroduce exactly the
+# silent success #1455 exists to kill — this time in the fix for it. So assert
+# the response really is a PR object: an object carrying a numeric `number` AND
+# a non-empty browser URL. Anything else is a failure, however it is dressed.
+result=$(printf '%s' "$response" | jq -c '
+  if type != "object" then empty
+  elif (.number | type) != "number" then empty
+  else
+    (.html_url // .url) as $url
+    | if ($url | type) == "string" and ($url | length) > 0
+      then {number: .number, url: $url}
+      else empty
+      end
+  end
+' 2>/dev/null) || result=
+
+if [ -z "$result" ]; then
+  # A numeric `number` with no usable URL means the PR WAS created and only the
+  # URL is missing. Say so, and name the number: the operator must not read this
+  # as "nothing happened" and retry into a duplicate.
+  number=$(printf '%s' "$response" | jq -r '
+    if type == "object" and (.number | type) == "number" then .number else empty end
+  ' 2>/dev/null) || number=
+  if [ -n "$number" ]; then
+    echo "pr-create: PR #$number WAS CREATED, but the Gitea response carried no browser URL." >&2
+    echo "pr-create: do not retry — that would open a duplicate. Response: $response" >&2
+    exit 1
+  fi
+
+  message=$(printf '%s' "$response" | jq -r '.message // empty' 2>/dev/null) || message=
+  if [ -n "$message" ]; then
+    echo "pr-create: Gitea refused to create the PR: $message" >&2
+  else
+    case "$response" in
+      404*)
+        # `{owner}`/`{repo}` stayed unsubstituted, so tea requested `repos//pulls`.
+        # Name the remedy rather than leaving a bare 404 (cf. `_lib.sh#gitea_repo`).
+        echo "pr-create: Gitea answered 404 — could not resolve owner/repo for this repository." >&2
+        echo "pr-create: set CODEV_PR_REPO=owner/repo, or run from a checkout whose remote is a configured Gitea host." >&2
+        ;;
+      *)
+        echo "pr-create: unexpected response from the Gitea API: $response" >&2
+        ;;
+    esac
+  fi
+  exit 1
+fi
+
+printf '%s\n' "$result"

package/scripts/forge/gitea/pr-exists.sh

@@ -1,6 +1,34 @@
 #!/bin/sh
 # Forge concept: pr-exists (Gitea via tea CLI)
-# Returns true for open or merged pulls only. Closed-not-merged pulls are excluded.
-# --state all fetches pulls in all states; without it, only open pulls are returned.
-# Gitea: merged PRs have state="closed" + merged=true; abandoned PRs have state="closed" + merged=false
-tea pulls list --state all --fields index --output json | jq "[.[] | select(.head.ref == \"$CODEV_BRANCH_NAME\" and (.state == \"open\" or (.state == \"closed\" and .merged == true)))] | length > 0"
+# forge-executable: tea
+# Input: CODEV_BRANCH_NAME
+# Output: "true" or "false"
+#
+# Returns true for OPEN or MERGED pulls only; closed-not-merged pulls are
+# excluded. `tea pulls list` emits `.head` as a string (not `{ref}`) and reports
+# merged PRs as state "merged" with no `.merged` boolean, so its output can't
+# satisfy the `.head.ref` / `.merged` predicate below. Route through the raw
+# REST passthrough, whose PR objects carry nested `.head.ref` and a `.merged`
+# bool. `tea api` needs an explicit owner/repo in the path (unlike `tea pulls`,
+# which auto-detects it from the local git remote), so resolve it here: honor
+# CODEV_REPO when set, else derive owner/repo from origin's URL (handles https,
+# ssh, and scp-style remotes, with or without a .git suffix).
+#
+# Caveat (Gitea behavior, not a codev bug): for a merged PR whose source branch
+# was deleted, Gitea returns `.head.ref == "refs/pull/N/head"` instead of the
+# original branch name, so a branch-name match won't hit a merged+deleted
+# branch. That doesn't affect the "does an open/merged PR exist for the branch
+# I'm about to push" use case.
+#
+# `state=all` is paginated (Gitea caps a page at max_response_items, default 50)
+# so a branch whose PR isn't in the most recent ~50 would false-negative and
+# block a porch pr_exists gate — tea_api_paged walks every page (see _lib.sh).
+. "$(dirname "$0")/_lib.sh"
+REPO="$(gitea_repo)" || exit 1
+# Capture the paginator's output before piping to jq: in POSIX sh (no
+# pipefail), a `cmd | jq` pipeline reports jq's exit status (0) even when
+# `cmd` failed mid-walk, which would surface a real error as a false-negative
+# "no PR exists" and silently pass a porch pr_exists gate.
+PULLS="$(tea_api_paged "repos/${REPO}/pulls" "state=all")" || exit 1
+printf '%s' "$PULLS" | jq --arg branch "$CODEV_BRANCH_NAME" \
+    '[.[] | select(.head.ref == $branch and (.state == "open" or .merged == true))] | length > 0'

package/scripts/forge/gitea/pr-list.sh

@@ -1,36 +1,45 @@
 #!/bin/sh
-# Forge concept: pr-list (Gitea via tea CLI)
+# Forge concept: pr-list (Gitea via tea CLI) — open pulls
+# forge-executable: tea
+# Output: JSON [{number, title, url, reviewDecision, body, createdAt, author,
+#                reviewRequests, isDraft}]  (PrListItem in forge-contracts.ts)
 #
-# Normalize tea's PR shape to the GitHub-compatible shape codev expects
-# (see PrListItem in codev/src/lib/forge-contracts.ts):
-#   index            -> number (int)
-#   description      -> body
-#   created          -> createdAt
-#   author (string)  -> author.login
-#   reviewDecision   -> ""  (Gitea has no GitHub-equivalent review-decision summary)
-#   reviewRequests   -> []  (verified against tea 0.14.1: `pulls list` exposes
-#                            no `reviewers` field, and its JSON output is limited
-#                            to the selectable `--fields`, so requested reviewers
-#                            are unreachable here. The VSCode sort silently skips
-#                            the review-requested bucket when empty.)
-#   isDraft          -> false (verified: tea 0.14.1 `pulls list` exposes no
-#                              `draft` field among its selectable `--fields`.)
-# The underlying Gitea API PR object does carry `draft` and `requested_reviewers`,
-# but only the raw `tea api` passthrough can reach them — populating these two
-# fields for Gitea would mean reworking this concept onto `tea api`, which is a
-# separate, larger change than #787's scope.
-exec tea pulls list --limit 200 \
-  --fields index,title,state,author,url,created,description \
-  --output json \
-  | jq '[.[] | {
-      number: (.index | tonumber),
+# `tea pulls list --fields …,description` errors ("invalid field 'description'")
+# and its flattened output can't carry a PR body, draft flag, or requested
+# reviewers. Route through the raw REST passthrough instead, whose PR objects
+# expose all of them. `tea api` needs an explicit owner/repo in the path (unlike
+# `tea pulls`, which auto-detects it from the local git remote), so resolve it
+# here: honor CODEV_REPO when set, else derive owner/repo from origin's URL
+# (handles https, ssh, and scp-style remotes, with or without a .git suffix).
+#
+# Field mapping:
+#   .number                       -> number (already an int in the REST shape)
+#   .html_url                     -> url (browser page; Gitea `.url` is the API endpoint)
+#   .body                         -> body
+#   .created_at                   -> createdAt
+#   .user.login                   -> author.login
+#   .requested_reviewers[].login  -> reviewRequests (user logins; teams have no login → dropped)
+#   .draft                        -> isDraft
+#   reviewDecision                -> ""  (Gitea has no GitHub-equivalent review-decision summary)
+#
+# The open-pulls list is paginated (Gitea caps a page at max_response_items,
+# default 50), so tea_api_paged walks every page rather than silently truncating
+# at ~50 open PRs (see _lib.sh).
+. "$(dirname "$0")/_lib.sh"
+REPO="$(gitea_repo)" || exit 1
+# Capture the paginator's output before piping to jq: in POSIX sh (no
+# pipefail), a `cmd | jq` pipeline reports jq's exit status (0) even when
+# `cmd` failed mid-walk, which would silently truncate the list instead of
+# surfacing the error.
+PULLS="$(tea_api_paged "repos/${REPO}/pulls" "state=open")" || exit 1
+printf '%s' "$PULLS" | jq '[.[] | {
+      number,
       title,
-      state,
-      url,
+      url: (.html_url // .url),
       reviewDecision: "",
-      body: (.description // ""),
-      createdAt: .created,
-      author: {login: .author},
-      reviewRequests: [],
-      isDraft: false
+      body: (.body // ""),
+      createdAt: .created_at,
+      author: {login: .user.login},
+      reviewRequests: [ (.requested_reviewers // [])[] | .login // empty ],
+      isDraft: (.draft // false)
     }]'

package/scripts/forge/gitea/pr-view.sh

@@ -1,6 +1,67 @@
 #!/bin/sh
 # Forge concept: pr-view (Gitea via tea CLI)
-# Sets `url` to the PR's browser page (`html_url`). Gitea's own `url` field is
-# the API endpoint (would render raw JSON in a browser), so we prefer `html_url`
-# and fall back to the existing `url` only if `html_url` is absent.
-tea pulls view "$CODEV_PR_NUMBER" --output json | jq '.url = (.html_url // .url)'
+# forge-executable: tea
+# Input: CODEV_PR_NUMBER
+# Output: JSON {title, body, state, url, author{login}, baseRefName, headRefName,
+#               additions, deletions}  (see PrViewResult in forge-contracts.ts)
+#
+# `tea pulls view N --output json` returns a table header / empty list rather
+# than the PR object, so route through the raw REST passthrough. `tea api`
+# needs an explicit owner/repo in the path (unlike `tea pulls`, which
+# auto-detects it from the local git remote), so resolve it here: honor
+# CODEV_REPO when set, else derive owner/repo from origin's URL (handles
+# https, ssh, and scp-style remotes, with or without a .git suffix).
+#
+# `url` is the PR's browser page (`html_url`). Gitea's own `url` field is the
+# API endpoint (would render raw JSON in a browser), so map `html_url` and fall
+# back to `url` only if it's absent — the same choice PIR #1179 made when this
+# concept still went through `tea pulls view`.
+#
+# SHAPE VALIDATION. `tea api` exits 0 on an HTTP error and prints the error
+# BODY, e.g. {"message":"pull does not exist [index: 42]","url":"…/swagger"}.
+# Normalizing that unchecked produced a structurally valid, entirely wrong
+# contract object at exit 0 — every field null except `url`, which took the
+# error body's own `url` (the swagger link) and shipped it to callers as the
+# PR's browser page. Required fields are type-checked first and anything else
+# is a hard failure carrying the server's message on stderr.
+. "$(dirname "$0")/_lib.sh"
+REPO="$(gitea_repo)" || exit 1
+# Capture before piping: in POSIX sh (no pipefail) a `tea api … | jq` pipeline
+# reports jq's exit status, so a failed fetch would surface as jq's exit-0 on
+# empty stdin rather than an error.
+PR="$(tea api "repos/${REPO}/pulls/${CODEV_PR_NUMBER}")" || exit 1
+# An empty body at exit 0 would give jq nothing to work on: it emits no output
+# and exits 0, so the script would "succeed" with empty stdout instead of
+# failing. The validator below never runs on an empty response, so guard here.
+if [ -z "$PR" ]; then
+  echo "gitea forge: empty \`tea api\` response for pull ${CODEV_PR_NUMBER}" >&2
+  exit 1
+fi
+printf '%s' "$PR" | jq '
+  if (type == "object")
+     and ((.number | type) == "number")
+     and ((.title | type) == "string")
+     and ((.state | type) == "string")
+     and ((.user.login | type) == "string")
+     and ((.base.ref | type) == "string")
+     and ((.head.ref | type) == "string")
+  then .
+  else
+    ("gitea forge: unexpected `tea api` response for pull "
+      + (env.CODEV_PR_NUMBER // "?") + ": "
+      + ((.message // .) | tostring)
+      + "\n") | halt_error(1)
+  end
+  | {
+  title,
+  body: (.body // ""),
+  state,
+  url: (.html_url // .url),
+  author: {login: .user.login},
+  baseRefName: .base.ref,
+  headRefName: .head.ref,
+  # Type-checked, not just defaulted: the contract types these as numbers, and
+  # a non-numeric value here would be passed straight through.
+  additions: (if (.additions | type) == "number" then .additions else 0 end),
+  deletions: (if (.deletions | type) == "number" then .deletions else 0 end)
+}'

package/scripts/forge/gitea/recently-merged.sh

@@ -1,27 +1,97 @@
 #!/bin/sh
 # Forge concept: recently-merged (Gitea via tea CLI)
+# forge-executable: tea
+# Input: CODEV_SINCE_DATE (optional, ISO-8601 timestamp)
+# Output: JSON [{number, title, url, body, createdAt, mergedAt, headRefName}]
+#         (MergedPrItem in forge-contracts.ts)
 #
-# `tea pulls list --state closed` returns both merged PRs and closed-without-
-# merge PRs. Filter to merged only via `.merged == true` (the same predicate
-# scripts/forge/gitea/pr-exists.sh already relies on), then map to the
-# GitHub-compatible shape:
-#   index           -> number (int)
-#   created         -> createdAt
-#   updated         -> mergedAt  (tea exposes no merged_at field via --fields;
-#                                 close-then-edit overestimates merged time
-#                                 but is acceptable for the 24h overview window)
-#   head.ref        -> headRefName
-#   description     -> body
-exec tea pulls list --state closed --limit 1000 \
-  --fields index,title,state,author,url,created,updated,head,description,merged \
-  --output json \
-  | jq '[.[] | select(.merged == true) | {
-      number: (.index | tonumber),
+# `tea pulls list --fields …,head,description,merged` errors on the `description`
+# field and emits `.head` as a string, so it can't populate `body` or
+# `.head.ref`. Route through the raw REST passthrough instead, whose closed
+# pulls carry `.merged`, `.merged_at`, nested `.head.ref`, and `.body`. Keep
+# only merged pulls (closed-without-merge have `.merged == false`). `tea api`
+# needs an explicit owner/repo in the path (unlike `tea pulls`, which
+# auto-detects it from the local git remote), so resolve it here: honor
+# CODEV_REPO when set, else derive owner/repo from origin's URL (handles https,
+# ssh, and scp-style remotes, with or without a .git suffix).
+#
+# The closed-pulls list is paginated (Gitea caps a page at max_response_items,
+# default 50), so on a busy repo the most-recent merges could push older ones
+# past the first page — tea_api_paged walks every page (see _lib.sh).
+#
+# CODEV_SINCE_DATE BOUNDS THE WALK. This concept feeds a 24h analytics window,
+# but the closed-pulls list is the repo's whole merge history: on an
+# established repo an unbounded walk issues up to GITEA_MAX_PAGES sequential
+# requests inside forge's 30s timeout, and a timeout yields `null` — a worse
+# outcome for the dashboard than truncation was. When CODEV_SINCE_DATE is set
+# we ask the server for update-time-descending order and stop at the first page
+# that reaches back past the cutoff.
+#
+# The stop filter does not take the sort on trust. What it actually needs is
+# the ORDERING, not the parameter, so it checks for the ordering directly and
+# fires only when all of this holds:
+#   - the current page is non-increasing in `updated_at`,
+#   - the PREVIOUS page was too, and its oldest entry is no older than this
+#     page's newest — i.e. the order survives a page boundary, so page-local
+#     sorting or a coincidentally-descending first page isn't enough,
+#   - some entry on this page predates the cutoff.
+# Never on page 1: with nothing to compare against, one internally-descending
+# page proves nothing about the pages behind it. Costing one extra request is
+# the right trade against dropping a merge.
+#
+# Given that ordering, `updated_at >= merged_at` (a merge updates the PR) means
+# nothing merged after the cutoff can sit beyond the first page whose update
+# times have fallen behind it. A server that ignores `sort=recentupdate` fails
+# these checks and we fall back to the full walk — slower, never wrong.
+#
+# Timestamps go through `gitea_epoch` because Gitea emits RFC3339 in the
+# server's timezone, not necessarily `Z`.
+. "$(dirname "$0")/_lib.sh"
+REPO="$(gitea_repo)" || exit 1
+
+if [ -n "$CODEV_SINCE_DATE" ]; then
+  QUERY="state=closed&sort=recentupdate"
+  # `$prev` is the previous page, bound by tea_api_paged (null on page 1).
+  STOP="${GITEA_JQ_LIB}"'
+    def descending: . as $a | [ range(($a | length) - 1) | $a[.] >= $a[. + 1] ] | all;
+    def times: [ .[] | (.updated_at | gitea_epoch) ];
+
+    times as $t
+    | ($prev | if . == null then null else times end) as $p
+    | (env.CODEV_SINCE_DATE | gitea_epoch) as $since
+    | ($since != null)
+      and ($p != null)
+      and (($t | length) > 0) and (($p | length) > 0)
+      and ([ $t[] | . != null ] | all) and ([ $p[] | . != null ] | all)
+      and ($t | descending) and ($p | descending)
+      and (($p | min) >= ($t | max))
+      and (($t | min) < $since)
+  '
+else
+  QUERY="state=closed"
+  STOP=""
+fi
+
+# Capture the paginator's output before piping to jq: in POSIX sh (no
+# pipefail), a `cmd | jq` pipeline reports jq's exit status (0) even when
+# `cmd` failed mid-walk, which would silently truncate the list instead of
+# surfacing the error.
+PULLS="$(tea_api_paged "repos/${REPO}/pulls" "$QUERY" "$STOP")" || exit 1
+printf '%s' "$PULLS" | jq "${GITEA_JQ_LIB}"'
+    (env.CODEV_SINCE_DATE | gitea_epoch) as $since
+    | [ .[]
+      | select(.merged == true)
+      # Drop merges older than the cutoff. An unparseable/absent timestamp on
+      # either side keeps the item — the caller filters the window again, so
+      # over-reporting is harmless where dropping a real merge is not.
+      | select($since == null
+               or ((.merged_at | gitea_epoch) as $m | $m == null or $m >= $since))
+      | {
+      number,
       title,
-      state,
-      url,
-      body: (.description // ""),
-      createdAt: .created,
-      mergedAt: .updated,
+      url: (.html_url // .url),
+      body: (.body // ""),
+      createdAt: .created_at,
+      mergedAt: .merged_at,
       headRefName: (.head.ref // "")
     }]'

package/scripts/forge/gitea/user-identity.sh

@@ -1,3 +1,32 @@
 #!/bin/sh
 # Forge concept: user-identity (Gitea via tea CLI)
-tea whoami --output json | jq -r ".login"
+# forge-executable: tea
+# Output: plain text username
+#
+# `tea whoami` has no `--output json` flag (its only documented option is
+# --help), so it can't feed a jq pipeline. Route through the raw REST
+# passthrough instead: `tea api user` returns the Gitea `User` object, whose
+# `.login` is the authenticated username (mirrors `gh api user --jq .login`).
+#
+# SHAPE VALIDATION. `tea api` exits 0 on an HTTP error and prints the error
+# BODY, which has no `.login` — `jq -r .login` then printed the literal string
+# "null" at exit 0, and callers took that as the current user's handle. Check
+# for a non-empty string login first and fail with the server's message
+# otherwise. The response is captured before the pipe because POSIX sh has no
+# pipefail: `tea api user | jq` would report jq's status, not tea's.
+USER_JSON="$(tea api user)" || exit 1
+# jq given empty input emits nothing and exits 0, so an empty body at exit 0
+# would leave the script "succeeding" with no username at all.
+if [ -z "$USER_JSON" ]; then
+  echo "gitea forge: empty \`tea api user\` response" >&2
+  exit 1
+fi
+printf '%s' "$USER_JSON" | jq -r '
+  if (type == "object") and ((.login | type) == "string")
+     and ((.login | test("^\\s*$")) | not)
+  then .login
+  else
+    ("gitea forge: unexpected `tea api user` response: "
+      + ((.message // .) | tostring)
+      + "\n") | halt_error(1)
+  end'

package/scripts/forge/github/issue-view.sh

@@ -1,5 +1,8 @@
 #!/bin/sh
 # Forge concept: issue-view (GitHub via gh CLI)
 # Input: CODEV_ISSUE_ID
-# Output: JSON {title, body, state, url, comments[]}
-exec gh issue view "$CODEV_ISSUE_ID" --json title,body,state,url,comments
+# Output: JSON {title, body, state, url, author, createdAt, assignees, labels, milestone, comments[]}
+# author/createdAt/assignees/labels/milestone are optional by contract; `gh`
+# emits them in the neutral shapes the IssueView contract expects (author.login,
+# assignees[].login, labels[].name, milestone.title or null when unset).
+exec gh issue view "$CODEV_ISSUE_ID" --json title,body,state,url,author,createdAt,assignees,labels,milestone,comments

package/scripts/forge/github/pr-create.sh

@@ -0,0 +1,47 @@
+#!/bin/sh
+# Forge concept: pr-create (GitHub via gh CLI)
+# forge-executable: gh
+#
+# Input:  CODEV_PR_TITLE (required)
+#         CODEV_PR_BODY  (required, may be empty)
+#         CODEV_PR_BASE, CODEV_PR_HEAD, CODEV_PR_REPO, CODEV_PR_DRAFT (optional)
+# Output: {"number": <int>, "url": "<web url>"}
+#
+# `gh pr create` prints the new PR's URL on stdout; the number is its last path
+# segment. Anything gh writes that isn't a URL (hints, prompts) is ignored.
+set -e
+
+if [ -z "$CODEV_PR_TITLE" ]; then
+  echo "pr-create: CODEV_PR_TITLE is required" >&2
+  exit 2
+fi
+
+# An empty body is allowed; an *absent* one is not. Without this, forgetting the
+# variable opens a PR with no body at exit 0 — the silent failure #1455 is about.
+if [ -z "${CODEV_PR_BODY+x}" ]; then
+  echo "pr-create: CODEV_PR_BODY is required (set it to \"\" for an empty body)" >&2
+  exit 2
+fi
+
+set -- --title "$CODEV_PR_TITLE" --body "$CODEV_PR_BODY"
+if [ -n "$CODEV_PR_BASE" ]; then set -- "$@" --base "$CODEV_PR_BASE"; fi
+if [ -n "$CODEV_PR_HEAD" ]; then set -- "$@" --head "$CODEV_PR_HEAD"; fi
+if [ -n "$CODEV_PR_REPO" ]; then set -- "$@" --repo "$CODEV_PR_REPO"; fi
+if [ "$CODEV_PR_DRAFT" = "1" ]; then set -- "$@" --draft; fi
+
+url=$(gh pr create "$@" | grep -E '^https?://' | tail -n 1)
+
+if [ -z "$url" ]; then
+  echo "pr-create: gh pr create returned no PR URL" >&2
+  exit 1
+fi
+
+number=${url##*/}
+case "$number" in
+  '' | *[!0-9]*)
+    echo "pr-create: could not parse a PR number from '$url'" >&2
+    exit 1
+    ;;
+esac
+
+printf '{"number":%s,"url":"%s"}\n' "$number" "$url"

package/scripts/forge/github/pr-search.sh

@@ -2,4 +2,6 @@
 # Forge concept: pr-search (GitHub via gh CLI)
 # Input: CODEV_SEARCH_QUERY
 # Output: JSON [{number, headRefName, baseRefName}]
-exec gh pr list --search "$CODEV_SEARCH_QUERY" --json number,headRefName,baseRefName
+# --state all is required so the search includes merged/closed PRs; without it
+# `gh pr list` defaults to --state open and post-merge lookups return nothing (#759).
+exec gh pr list --state all --search "$CODEV_SEARCH_QUERY" --json number,headRefName,baseRefName

package/scripts/forge/gitlab/issue-view.sh

@@ -1,6 +1,26 @@
 #!/bin/sh
 # Forge concept: issue-view (GitLab via glab CLI)
-# Adds a `url` field mapped from GitLab's `web_url` (the issue's browser page);
-# all other fields glab emits are passed through unchanged. `. + {url: …}` is
-# non-destructive — if `web_url` is absent, `url` is null (optional by contract).
-glab issue view "$CODEV_ISSUE_ID" --output json | jq '. + {url: .web_url}'
+# Maps GitLab's fields into the forge-neutral IssueView shape. `. + {…}` is
+# non-destructive for keys we don't touch; the mapped keys are optional by
+# contract, so a shape mismatch degrades to an omitted line rather than a crash
+# (jq returns null for missing keys, and the guards below tolerate null):
+#   web_url            -> url
+#   author.username    -> author.login
+#   created_at         -> createdAt
+#   assignees[].username -> assignees[].login
+#   labels[]           -> labels[].name  (newer glab emits label objects; older emits strings)
+#   milestone.title    -> milestone.title (null when unset)
+# Best-effort preset (Spec 589): fields GitLab doesn't expose stay absent. The
+# contract's optional fields are added only when present (via `+ {…}` merges) so
+# an absent field is OMITTED, not emitted as null — `author?`/`createdAt?` are not
+# nullable (only `milestone` is). `exec` is dropped: with a pipe it would replace
+# only the glab subshell, not the whole pipeline, so it's misleading here.
+glab issue view "$CODEV_ISSUE_ID" --output json | jq '
+  .
+  + {url: .web_url}
+  + {assignees: [(.assignees // [])[] | {login: .username}]}
+  + {labels: [(.labels // [])[] | if type == "string" then {name: .} else {name: .name} end]}
+  + (if .author.username then {author: {login: .author.username}} else {} end)
+  + (if .created_at then {createdAt: .created_at} else {} end)
+  + (if .milestone then {milestone: {title: .milestone.title}} else {} end)
+'