forge-workflow 0.0.9 → 0.1.0-beta.2

package/scripts/forge-team/lib/hooks.sh

@@ -8,8 +8,8 @@
 #
 # Env overrides (for testing):
 #   GH_CMD      — Path to gh binary (default: gh)
-#   BD_CMD      — Path to bd binary (default: bd)
-#   BEADS_ROOT  — Path to .beads/ parent directory (default: .)
+#   FORGE_CMD   — Path to forge binary (default: forge)
+#   FORGE_ROOT  — Path to .forge/ parent directory (default: .)
 #
 # This file does NOT set errexit/pipefail — callers manage their own shell options.
 
@@ -56,11 +56,11 @@ _hooks_warn() {
 }
 
 # ── _check_auto_sync_enabled ─────────────────────────────────────────────
-# Reads .beads/config.yaml for team.auto-sync setting.
+# Reads .forge/config.yaml for the team.auto-sync setting.
 # Returns 0 if enabled (default), 1 if disabled.
 _check_auto_sync_enabled() {
-  local beads_root="${BEADS_ROOT:-.}"
-  local config_file="$beads_root/.beads/config.yaml"
+  local forge_root="${FORGE_ROOT:-.}"
+  local config_file="$forge_root/.forge/config.yaml"
 
   if [[ ! -f "$config_file" ]]; then
     # Default: enabled
@@ -108,7 +108,7 @@ forge_team_sync() {
   done
 
   local gh_cmd="${GH_CMD:-gh}"
-  local bd_cmd="${BD_CMD:-bd}"
+  local forge_cmd="${FORGE_CMD:-forge}"
 
   # 1. Check gh auth status
   if ! "$gh_cmd" auth status >/dev/null 2>&1; then
@@ -122,44 +122,42 @@ forge_team_sync() {
     return 0
   fi
 
-  # 3. Get all in_progress issues
-  local list_output
-  list_output="$("$bd_cmd" list --status=in_progress 2>/dev/null)" || {
+  # 3. Get all in_progress issues as JSON
+  local list_json
+  list_json="$("$forge_cmd" issue list --status=in_progress --json 2>/dev/null)" || {
     if [[ "$quiet" == "false" ]]; then
       _hooks_warn "Failed to list issues, sync skipped"
     fi
     return 0
   }
 
-  # Filter empty lines
-  if [[ -z "$list_output" ]] || [[ -z "$(echo "$list_output" | tr -d '[:space:]')" ]]; then
+  # Build "id<TAB>has_github" lines (has_github is true when a github_issue:<n>
+  # label is present on the issue).
+  local issue_lines
+  issue_lines="$(printf '%s' "$list_json" | jq -r '
+    (.data.issues // [])[]
+    | [ .id, (((.labels // []) | any(test("^github_issue:"))) | tostring) ]
+    | join("\t")' 2>/dev/null | tr -d '\r')"
+
+  if [[ -z "$issue_lines" ]] || [[ -z "$(printf '%s' "$issue_lines" | tr -d '[:space:]')" ]]; then
     if [[ "$quiet" == "false" ]]; then
       _hooks_info "Nothing to sync"
     fi
     return 0
   fi
 
-  # 4. For each issue, check for github_issue state and sync
+  # 4. For each issue with a github_issue label, sync its status to GitHub
   local synced=0
   local warnings=0
 
-  while IFS= read -r line; do
-    [[ -z "$line" ]] && continue
-
-    # Extract issue id
-    local issue_id
-    issue_id="$(echo "$line" | grep -oE 'forge-[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)*' | head -1)"
+  while IFS=$'\t' read -r issue_id has_github; do
     [[ -z "$issue_id" ]] && continue
 
-    # Get details to check for github_issue state
-    local show_output
-    show_output="$("$bd_cmd" show "$issue_id" 2>/dev/null)" || continue
-
-    # Check if it has github_issue:N state
-    local gh_issue_num
-    gh_issue_num="$(printf '%s' "$show_output" | grep -oP 'github_issue:\K[0-9]+' | head -1 || true)"
-
-    if [[ -z "$gh_issue_num" ]]; then
+    # Skip only when there is neither a github_issue:<n> label nor a legacy
+    # mapping-file association. _get_github_issue_number (from sync-github.sh)
+    # checks the label first, then the mapping-file fallback, so mapping-only
+    # linked issues are still synced instead of being skipped here.
+    if [[ "$has_github" != "true" ]] && ! _get_github_issue_number "$issue_id" >/dev/null 2>&1; then
       # No GitHub issue linked, skip but warn
       warnings=$((warnings + 1))
       if [[ "$quiet" == "false" ]]; then
@@ -177,7 +175,7 @@ forge_team_sync() {
         _hooks_warn "Failed to sync $issue_id to GitHub"
       fi
     fi
-  done <<< "$list_output"
+  done <<< "$issue_lines"
 
   # 5. Report
   if [[ "$quiet" == "false" ]]; then

package/scripts/forge-team/lib/identity.sh

@@ -2,7 +2,7 @@
 # scripts/forge-team/lib/identity.sh — GitHub-username-only identity mapping
 #
 # Auto-detects developer via `gh api user`. Stores identity in
-# .beads/team-map.jsonl (append-only, LWW per GitHub username).
+# .forge/team-map.jsonl (append-only, LWW per GitHub username).
 #
 # Functions:
 #   get_github_user       — Current dev's GitHub username (cached)
@@ -14,7 +14,7 @@
 #
 # Env overrides:
 #   GH_CMD          — Path to gh binary (for testing)
-#   TEAM_MAP_ROOT   — Root dir for .beads/team-map.jsonl (default: .)
+#   TEAM_MAP_ROOT   — Root dir for .forge/team-map.jsonl (default: .)
 #
 # This file does NOT set errexit/pipefail — callers manage their own shell options.
 
@@ -69,7 +69,7 @@ _identity_prompt() {
 # _team_map_file — Returns the path to team-map.jsonl
 _team_map_file() {
   local root="${TEAM_MAP_ROOT:-.}"
-  printf '%s' "$root/.beads/team-map.jsonl"
+  printf '%s' "$root/.forge/team-map.jsonl"
 }
 
 # _validate_github_username <username>
@@ -124,7 +124,7 @@ get_github_user() {
 }
 
 # team_map_add <github-user> [display-name]
-# Adds/updates entry in .beads/team-map.jsonl.
+# Adds/updates entry in .forge/team-map.jsonl.
 # Schema: {"github":"<user>","display_name":"<name>","updated_at":"<ts>","is_bot":false}
 team_map_add() {
   local github_user="${1:-}"

package/scripts/forge-team/lib/sync-github.sh

@@ -1,17 +1,17 @@
 #!/usr/bin/env bash
-# scripts/forge-team/lib/sync-github.sh — Bidirectional sync between Beads and GitHub
+# scripts/forge-team/lib/sync-github.sh — Bidirectional sync between Forge issues and GitHub
 #
 # Functions:
-#   sync_issue_create  <beads-id>             — Create GitHub issue from Beads
-#   sync_issue_claim   <beads-id>             — Assign current dev on GitHub
-#   sync_issue_status  <beads-id> <status>    — Update status label on GitHub
-#   sync_issue_close   <beads-id>             — Close GitHub issue
-#   sync_issue_deps    <beads-id-a> <beads-id-b> — Add "Blocked by" comment
-#   _get_github_issue_number <beads-id>       — Extract github_issue from bd show
+#   sync_issue_create  <issue-id>             — Create GitHub issue from a Forge issue
+#   sync_issue_claim   <issue-id>             — Assign current dev on GitHub
+#   sync_issue_status  <issue-id> <status>    — Update status label on GitHub
+#   sync_issue_close   <issue-id>             — Close GitHub issue
+#   sync_issue_deps    <issue-id-a> <issue-id-b> — Add "Blocked by" comment
+#   _get_github_issue_number <issue-id>       — Extract canonical GitHub issue from issue show
 #
 # Env overrides (for testing):
-#   GH_CMD  — Path to gh binary (default: gh)
-#   BD_CMD  — Path to bd binary (default: bd)
+#   GH_CMD    — Path to gh binary (default: gh)
+#   FORGE_CMD — Path to forge binary (default: forge)
 #
 # All GitHub-sourced strings are sanitized via sanitize_for_agent() before
 # use in shell commands (OWASP A03).
@@ -71,29 +71,123 @@ _safe_sanitize() {
   printf '%s' "$input"
 }
 
+_extract_issue_number_from_url() {
+  local input="${1:-}"
+  local suffix="${input##*/issues/}"
+
+  if [[ "$suffix" == "$input" ]]; then
+    return 1
+  fi
+
+  suffix="${suffix%%[^0-9]*}"
+  if [[ -z "$suffix" ]]; then
+    return 1
+  fi
+
+  printf '%s' "$suffix"
+}
+
+_sync_mapping_file() {
+  local root="${TEAM_MAP_ROOT:-.}"
+  printf '%s' "${SYNC_MAPPING_FILE:-$root/.github/beads-mapping.json}"
+}
+
+_persist_issue_mapping() {
+  local beads_id="${1:-}"
+  local issue_num="${2:-}"
+  local mapping_file
+  mapping_file="$(_sync_mapping_file)"
+
+  node - "$mapping_file" "$issue_num" "$beads_id" <<'NODE'
+const fs = require('node:fs');
+const path = require('node:path');
+
+const [mappingPath, issueNum, beadsId] = process.argv.slice(2);
+let data = {};
+
+if (fs.existsSync(mappingPath)) {
+  const raw = fs.readFileSync(mappingPath, 'utf8').trim();
+  if (raw) {
+    data = JSON.parse(raw);
+  }
+}
+
+fs.mkdirSync(path.dirname(mappingPath), { recursive: true });
+data[String(issueNum)] = beadsId;
+fs.writeFileSync(mappingPath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+NODE
+}
+
+_get_issue_number_from_mapping() {
+  local beads_id="${1:-}"
+  local mapping_file
+  mapping_file="$(_sync_mapping_file)"
+
+  node - "$mapping_file" "$beads_id" <<'NODE'
+const fs = require('node:fs');
+
+const [mappingPath, beadsId] = process.argv.slice(2);
+if (!fs.existsSync(mappingPath)) {
+  process.exit(0);
+}
+
+const raw = fs.readFileSync(mappingPath, 'utf8').trim();
+if (!raw) {
+  process.exit(0);
+}
+
+const data = JSON.parse(raw);
+let newestIssueNum = null;
+for (const [issueNum, mappedBeadsId] of Object.entries(data)) {
+  if (mappedBeadsId !== beadsId) {
+    continue;
+  }
+  const parsedIssueNum = Number.parseInt(issueNum, 10);
+  if (!Number.isFinite(parsedIssueNum)) {
+    continue;
+  }
+  if (newestIssueNum == null || parsedIssueNum > newestIssueNum) {
+    newestIssueNum = parsedIssueNum;
+  }
+}
+if (newestIssueNum != null) {
+  process.stdout.write(String(newestIssueNum));
+}
+NODE
+}
+
 # ── _get_github_issue_number ─────────────────────────────────────────────
-# Extracts github_issue number from `bd show <id>` output.
-# Looks for `github_issue:N` pattern.
+# Extracts the canonical GitHub issue number from the issue's github_issue:<n>
+# label (via `issue show <id> --json`), falling back to the local mapping file.
 # Returns the number or empty string (exit 1 if not found).
 _get_github_issue_number() {
   local beads_id="${1:-}"
   if [[ -z "$beads_id" ]]; then
-    _sync_error "beads-id required"
+    _sync_error "issue id required"
     return 1
   fi
 
-  local bd_cmd="${BD_CMD:-bd}"
+  local forge_cmd="${FORGE_CMD:-forge}"
   local show_output
-  show_output="$("$bd_cmd" show "$beads_id" 2>/dev/null)" || {
-    _sync_error "Failed to get beads info for $beads_id"
+  show_output="$("$forge_cmd" issue show "$beads_id" --json 2>/dev/null)" || {
+    _sync_error "Failed to get issue info for $beads_id"
     return 1
   }
 
   local issue_num
-  issue_num="$(printf '%s' "$show_output" | grep -oP 'github_issue:\K[0-9]+' | head -1)"
+  issue_num="$(printf '%s' "$show_output" | jq -r '
+    (.data.issue // .data // {})
+    | (.labels // [])
+    | map(select(startswith("github_issue:")))
+    | (.[0] // "")
+    | ltrimstr("github_issue:")' 2>/dev/null)"
 
   if [[ -z "$issue_num" ]]; then
-    _sync_error "No github_issue found for $beads_id"
+    issue_num="$(_get_issue_number_from_mapping "$beads_id" 2>/dev/null || true)"
+  fi
+
+  if [[ -z "$issue_num" ]]; then
+    _sync_error "No canonical GitHub number found for $beads_id"
     return 1
   fi
 
@@ -102,22 +196,16 @@ _get_github_issue_number() {
 }
 
 # ── _get_issue_title ─────────────────────────────────────────────────────
-# Extracts issue title from `bd show <id>` output.
-# Looks for "Title: <text>" line or falls back to the summary line.
+# Extracts the issue title from `issue show <id> --json`. Falls back to the
+# issue id when the title is empty.
 _get_issue_title() {
   local beads_id="${1:-}"
-  local bd_cmd="${BD_CMD:-bd}"
+  local forge_cmd="${FORGE_CMD:-forge}"
   local show_output
-  show_output="$("$bd_cmd" show "$beads_id" 2>/dev/null)" || return 1
+  show_output="$("$forge_cmd" issue show "$beads_id" --json 2>/dev/null)" || return 1
 
   local title
-  # Try "Title: ..." line first
-  title="$(printf '%s' "$show_output" | grep -oP '^Title:\s*\K.*' | head -1)"
-
-  if [[ -z "$title" ]]; then
-    # Fallback: extract from summary line "○ <id> · <title> [...]"
-    title="$(printf '%s' "$show_output" | grep -oP '·\s*\K[^\[]+' | head -1 | sed 's/[[:space:]]*$//')"
-  fi
+  title="$(printf '%s' "$show_output" | jq -r '(.data.issue // .data // {}) | (.title // "")' 2>/dev/null)"
 
   if [[ -z "$title" ]]; then
     title="$beads_id"
@@ -128,9 +216,10 @@ _get_issue_title() {
 
 # ── Public API ───────────────────────────────────────────────────────────
 
-# sync_issue_create <beads-id>
-# Creates GitHub issue from Beads issue data.
-# Stores GitHub issue number back via `bd set-state`.
+# sync_issue_create <issue-id>
+# Creates a GitHub issue from the Forge issue data.
+# Persists both the canonical mapping file and the github_issue:<n> label so
+# that downstream hook and verify flows can resolve the GitHub association.
 # Returns 0 on success, 1 on failure.
 sync_issue_create() {
   local beads_id="${1:-}"
@@ -140,9 +229,24 @@ sync_issue_create() {
   fi
 
   local gh_cmd="${GH_CMD:-gh}"
-  local bd_cmd="${BD_CMD:-bd}"
+  local forge_cmd="${FORGE_CMD:-forge}"
+
+  # Retry-safety / idempotency: the mapping file is persisted *before* the
+  # github_issue:<n> label is stored, so a previous run that created the GitHub
+  # issue and mapping but failed on the label leaves a recoverable mapping entry.
+  # On retry, repair the missing label from the mapping instead of calling
+  # `gh issue create` again and creating a duplicate GitHub issue.
+  local existing_num
+  existing_num="$(_get_issue_number_from_mapping "$beads_id" 2>/dev/null || true)"
+  if [[ -n "$existing_num" ]]; then
+    if ! "$forge_cmd" issue update "$beads_id" --label "github_issue:$existing_num" >/dev/null 2>&1; then
+      _sync_error "Failed to store github_issue:$existing_num for $beads_id"
+      return 1
+    fi
+    return 0
+  fi
 
-  # Get title from bd show
+  # Get title from the issue backend
   local raw_title
   raw_title="$(_get_issue_title "$beads_id")" || {
     _sync_error "Failed to get title for $beads_id"
@@ -162,28 +266,21 @@ sync_issue_create() {
 
   # Extract issue number from URL (e.g., https://github.com/.../issues/42)
   local issue_num
-  issue_num="$(printf '%s' "$gh_output" | grep -oP '/issues/\K[0-9]+' | head -1)"
+  issue_num="$(_extract_issue_number_from_url "$gh_output")"
 
   if [[ -z "$issue_num" ]]; then
     _sync_error "Could not extract issue number from: $gh_output"
     return 1
   fi
 
-  # Store issue number in Beads
-  "$bd_cmd" set-state "$beads_id" "github_issue=$issue_num" >/dev/null 2>&1 || {
-    _sync_error "Failed to store github_issue=$issue_num for $beads_id"
+  if ! _persist_issue_mapping "$beads_id" "$issue_num"; then
+    _sync_error "Failed to persist GitHub link for $beads_id"
     return 1
-  }
+  fi
 
-  # Update beads-mapping.json for verify Check 4
-  local mapping_file=".github/beads-mapping.json"
-  if [[ -f "$mapping_file" ]]; then
-    local updated
-    updated="$(jq --arg num "$issue_num" --arg id "$beads_id" '.[$num] = $id' "$mapping_file")"
-    printf '%s\n' "$updated" > "$mapping_file"
-  else
-    mkdir -p .github
-    printf '%s\n' "{\"$issue_num\":\"$beads_id\"}" > "$mapping_file"
+  if ! "$forge_cmd" issue update "$beads_id" --label "github_issue:$issue_num" >/dev/null 2>&1; then
+    _sync_error "Failed to store github_issue:$issue_num for $beads_id"
+    return 1
   fi
 
   return 0

package/scripts/forge-team/lib/verify.sh

@@ -7,15 +7,15 @@
 # Checks:
 #   1. gh auth status (GitHub CLI authenticated)
 #   2. Identity mapped in team-map.jsonl
-#   3. Orphan Beads issues (Beads without GitHub counterpart)
-#   4. Orphan GitHub issues (GitHub without Beads counterpart)
-#   5. Assignee consistency between Beads and GitHub
+#   3. Orphan tracked issues (no GitHub counterpart)
+#   4. Orphan GitHub issues (no tracked counterpart)
+#   5. Assignee consistency between tracked issues and GitHub
 #
 # Env overrides (for testing):
 #   GH_CMD              — Path to gh binary (default: gh)
-#   BD_CMD              — Path to bd binary (default: bd)
-#   TEAM_MAP_ROOT       — Root dir for .beads/ and .github/ (default: .)
-#   VERIFY_MAPPING_FILE — Path to beads-mapping.json (default: $TEAM_MAP_ROOT/.github/beads-mapping.json)
+#   FORGE_CMD           — Path to forge binary (default: forge)
+#   TEAM_MAP_ROOT       — Root dir for .forge/ and .github/ (default: .)
+#   VERIFY_MAPPING_FILE — Path to the GitHub issue mapping (default: $TEAM_MAP_ROOT/.github/beads-mapping.json)
 #
 # This file does NOT set errexit/pipefail — callers manage their own shell options.
 
@@ -66,16 +66,19 @@ _mapping_file() {
   printf '%s' "${VERIFY_MAPPING_FILE:-$root/.github/beads-mapping.json}"
 }
 
-# ── _extract_beads_ids ───────────────────────────────────────────────────
-# Parse bd list output to extract beads IDs.
-# Input format: "◐ forge-aaa · Feature A" or "○ forge-bbb · Feature B"
-# Output: one ID per line
-_extract_beads_ids() {
-  local input="${1:-}"
-  if [[ -z "$input" ]]; then
-    return 0
-  fi
-  printf '%s\n' "$input" | grep -oP '(forge-[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)*)' || true
+# ── _verify_active_issues_json ─────────────────────────────────────────────
+# Merged JSON array of open + in_progress issues. The Kernel list filter does
+# not accept comma-joined statuses, so query each status separately and
+# concatenate the issue arrays.
+_verify_active_issues_json() {
+  local forge_cmd="${FORGE_CMD:-forge}"
+  local open_json inprog_json
+  open_json="$("$forge_cmd" issue list --status=open --json 2>/dev/null)" || open_json=""
+  inprog_json="$("$forge_cmd" issue list --status=in_progress --json 2>/dev/null)" || inprog_json=""
+  jq -n \
+    --argjson a "${open_json:-null}" \
+    --argjson b "${inprog_json:-null}" \
+    '((($a.data.issues) // []) + (($b.data.issues) // []))' 2>/dev/null || echo "[]"
 }
 
 # ── Public API ───────────────────────────────────────────────────────────
@@ -84,7 +87,6 @@ _extract_beads_ids() {
 # Exit 0 if all clean, exit 1 if any issues found.
 cmd_verify() {
   local gh_cmd="${GH_CMD:-gh}"
-  local bd_cmd="${BD_CMD:-bd}"
   local issues_found=0
 
   echo "forge team verify"
@@ -130,47 +132,75 @@ cmd_verify() {
     issues_found=$((issues_found + 1))
   fi
 
-  # ── Check 3: Orphan Beads issues (Beads without GitHub) ─────────────
-  local bd_output
-  bd_output="$("$bd_cmd" list --status=open,in_progress 2>/dev/null)" || bd_output=""
-
-  local beads_ids
-  beads_ids="$(_extract_beads_ids "$bd_output")"
-
-  local beads_total=0
-  local beads_synced=0
-  local beads_orphans=()
-
-  if [[ -n "$beads_ids" ]]; then
-    while IFS= read -r bid; do
-      [[ -z "$bid" ]] && continue
-      beads_total=$((beads_total + 1))
-
-      # Check if this beads issue has github_issue state
-      local show_output
-      show_output="$("$bd_cmd" show "$bid" 2>/dev/null)" || show_output=""
-      if printf '%s' "$show_output" | grep -qP 'github_issue:\d+'; then
-        beads_synced=$((beads_synced + 1))
-      else
-        beads_orphans+=("$bid")
-      fi
-    done <<< "$beads_ids"
-  fi
+  # ── Association set: labels ∪ mapping (shared by Check 3 and Check 4) ─
+  # A GitHub↔Forge association can live in either the issue's `github_issue:<n>`
+  # label OR the local mapping file. Build a single set from BOTH so Check 3
+  # (Forge→GitHub) and Check 4 (GitHub→Forge) agree: a label-only or
+  # mapping-only association must never be misreported as an orphan.
+  local mapping_file
+  mapping_file="$(_mapping_file)"
+  local mapping_content="{}"
+  [[ -f "$mapping_file" ]] && mapping_content="$(cat "$mapping_file" 2>/dev/null || echo '{}')"
+
+  local issues_json
+  issues_json="$(_verify_active_issues_json)"
+
+  local -A assoc_gh_num=()   # associated GitHub numbers (mapping keys ∪ label numbers)
+  local -A assoc_beads=()    # associated Forge ids (mapping values ∪ labelled ids)
+
+  # From the mapping file: keys are GitHub numbers, values are Forge ids. The
+  # value is a string today; tolerate a legacy/forward object form ({beads_id}).
+  local _m_num _m_bid
+  while IFS=$'\t' read -r _m_num _m_bid; do
+    [[ -n "$_m_num" ]] && assoc_gh_num["$_m_num"]=1
+    [[ -n "$_m_bid" && "$_m_bid" != "null" ]] && assoc_beads["$_m_bid"]=1
+  done <<< "$(printf '%s' "$mapping_content" | jq -r '
+    to_entries[]
+    | [ (.key | tostring),
+        (if (.value | type) == "object" then (.value.beads_id // "") else (.value | tostring) end) ]
+    | @tsv' 2>/dev/null | tr -d '\r')"
+
+  # From active issues: a github_issue:<n> label links the issue id to number n.
+  local _l_id _l_num
+  while IFS=$'\t' read -r _l_id _l_num; do
+    [[ -z "$_l_id" ]] && continue
+    assoc_beads["$_l_id"]=1
+    [[ -n "$_l_num" ]] && assoc_gh_num["$_l_num"]=1
+  done <<< "$(printf '%s' "$issues_json" | jq -r '
+    .[]
+    | . as $x
+    | ((($x.labels // []) | map(select(startswith("github_issue:"))) | .[0] // "") | ltrimstr("github_issue:")) as $num
+    | select($num != "")
+    | [ $x.id, $num ] | @tsv' 2>/dev/null | tr -d '\r')"
+
+  # ── Check 3: Orphan tracked issues (no GitHub counterpart) ──────────
+  local issue_total issue_synced=0
+  issue_total="$(printf '%s' "$issues_json" | jq 'length' 2>/dev/null || echo 0)"
+
+  local issue_orphans=()
+  local _aid
+  while IFS= read -r _aid; do
+    [[ -z "$_aid" ]] && continue
+    if [[ -n "${assoc_beads[$_aid]:-}" ]]; then
+      issue_synced=$((issue_synced + 1))
+    else
+      issue_orphans+=("$_aid")
+    fi
+  done <<< "$(printf '%s' "$issues_json" | jq -r '.[].id' 2>/dev/null | tr -d '\r')"
 
-  if [[ ${#beads_orphans[@]} -eq 0 ]]; then
-    echo "✓ Beads→GitHub: ${beads_synced}/${beads_total} issues synced"
+  if [[ ${#issue_orphans[@]} -eq 0 ]]; then
+    echo "✓ Forge→GitHub: ${issue_synced}/${issue_total} issues synced"
   else
-    echo "✗ Beads→GitHub: ${#beads_orphans[@]} orphan issues found"
-    for orphan in "${beads_orphans[@]}"; do
+    echo "✗ Forge→GitHub: ${#issue_orphans[@]} orphan issues found"
+    for orphan in "${issue_orphans[@]}"; do
       _verify_prompt "${orphan} has no GitHub issue. Run: forge team sync-issue ${orphan}"
     done
-    issues_found=$((issues_found + ${#beads_orphans[@]}))
+    issues_found=$((issues_found + ${#issue_orphans[@]}))
   fi
 
-  # ── Check 4: Orphan GitHub issues (GitHub without Beads) ────────────
-  local mapping_file
-  mapping_file="$(_mapping_file)"
-
+  # ── Check 4: Orphan GitHub issues (no tracked counterpart) ──────────
+  # Uses the same association set: a GitHub number is mapped when it appears in
+  # the mapping file OR as a github_issue:<n> label on an active issue.
   local gh_issues_json
   gh_issues_json="$("$gh_cmd" issue list --state open --json number,title --limit 100 2>/dev/null)" || gh_issues_json="[]"
 
@@ -178,43 +208,23 @@ cmd_verify() {
   gh_issue_count="$(printf '%s' "$gh_issues_json" | jq 'length')"
 
   local gh_orphans=()
-
-  if [[ "$gh_issue_count" -gt 0 ]] && [[ -f "$mapping_file" ]]; then
-    local mapping_content
-    mapping_content="$(cat "$mapping_file")"
-
-    local i=0
-    while [[ $i -lt $gh_issue_count ]]; do
-      local issue_num
-      issue_num="$(printf '%s' "$gh_issues_json" | jq -r ".[$i].number")"
-
-      # Check if this GitHub issue number is a key in the mapping
-      local mapped
-      mapped="$(printf '%s' "$mapping_content" | jq -r --arg n "$issue_num" '.[$n] // empty')"
-
-      if [[ -z "$mapped" ]]; then
-        gh_orphans+=("$issue_num")
-      fi
-      i=$((i + 1))
-    done
-  elif [[ "$gh_issue_count" -gt 0 ]] && [[ ! -f "$mapping_file" ]]; then
-    # No mapping file — all GitHub issues are orphans
-    local i=0
-    while [[ $i -lt $gh_issue_count ]]; do
-      local issue_num
-      issue_num="$(printf '%s' "$gh_issues_json" | jq -r ".[$i].number")"
+  local i=0
+  while [[ $i -lt $gh_issue_count ]]; do
+    local issue_num
+    issue_num="$(printf '%s' "$gh_issues_json" | jq -r ".[$i].number")"
+    if [[ -z "${assoc_gh_num[$issue_num]:-}" ]]; then
       gh_orphans+=("$issue_num")
-      i=$((i + 1))
-    done
-  fi
+    fi
+    i=$((i + 1))
+  done
 
   if [[ ${#gh_orphans[@]} -eq 0 ]]; then
     local mapped_count=$((gh_issue_count))
-    echo "✓ GitHub→Beads: ${mapped_count}/${mapped_count} issues mapped"
+    echo "✓ GitHub→Forge: ${mapped_count}/${mapped_count} issues mapped"
   else
-    echo "✗ GitHub→Beads: ${#gh_orphans[@]} orphan issues found"
+    echo "✗ GitHub→Forge: ${#gh_orphans[@]} orphan issues found"
     for orphan_num in "${gh_orphans[@]}"; do
-      _verify_prompt "GitHub #${orphan_num} has no Beads issue. Run: forge team import #${orphan_num}"
+      _verify_prompt "GitHub #${orphan_num} has no tracked issue. Run: forge team import #${orphan_num}"
     done
     issues_found=$((issues_found + ${#gh_orphans[@]}))
   fi