@codyswann/lisa 2.223.3 → 2.225.0

package/plugins/lisa/skills/lisa-repair-intake/SKILL.md

@@ -6,7 +6,8 @@ allowed-tools: ["Skill", "Bash", "Read", "Write", "Edit"]
 
 # Repair Intake: $ARGUMENTS
 
-Run one batch-**repair** cycle against the queue identified by `$ARGUMENTS`. Where `lisa-intake`
+Run one batch-**repair** cycle against the queue identified by `$ARGUMENTS`, or by merged GitHub
+config when the queue is omitted and a GitHub source/tracker default is resolvable. Where `lisa-intake`
 scans the `ready` role and moves work *forward*, repair-intake scans the **stuck and
 close-out** roles and moves work *unstuck* or *fully closed*:
 
@@ -73,22 +74,24 @@ lifecycle state with provider-native closure and rollup state.
 ## Public contract
 
 ```text
-/lisa:repair-intake <queue> [intake_mode=prd|build|both] [stale_after=2h] [max_candidates=100] [force=true]
+/lisa:repair-intake [<queue>] [intake_mode=prd|build|both] [build_queue=owner/repo] [stale_after=2h] [max_candidates=100] [force=true]
 ```
 
 | Token | Meaning | Default |
 |-------|---------|---------|
-| `<queue>` | Same queue identifier `lisa-intake` accepts (see Source dispatch). Required. | — |
+| `<queue>` | Same queue identifier `lisa-intake` accepts (see Source dispatch). Optional only when merged config resolves a GitHub source/tracker and identity; otherwise required. | merged GitHub default when resolvable |
 | `intake_mode` | `prd` \| `build` \| `both`. Only meaningful for a GitHub `org/repo` (or bare `github`) that hosts both PRD and build label namespaces. `both` is unique to repair — a repair sweep usefully covers both lifecycles in one schedule. Absent → `both` when both namespaces exist, else whichever lifecycle exists. | `both` for dual GitHub queues; otherwise infer |
+| `build_queue` | GitHub build scan target used with literal `github`, especially `intake_mode=both`. Explicit `owner/repo` or URL for a build-only invocation wins over this token; otherwise this wins over `github.queueRepo`. It never redirects the PRD scan. | `github.queueRepo`, then `github.org/github.repo` |
 | `stale_after` | How long since the last state-changing transition into the in-progress role, or since the last human / PR-side forward-progress activity, before an in-progress item counts as stalled. Automation self-comments do not reset this clock. Accepts `24h`, `90m`, `2d`, or `0` (treat any in-progress item as stalled — manual recovery, also the only way to resume work on a provider that exposes no reliable timestamp). Overrides config. | `2h` |
 | `max_candidates` | Cap on how many stuck/close-out candidates to enumerate and evaluate. Repair every materially actionable candidate within this bounded set, then stop. Overrides config. | `100` |
 | `force` | `true` bypasses the loop-prevention backoff window (so a manual re-run re-attempts items even if their fingerprint is unchanged). It does **not** change the staleness rule — use `stale_after=0` for that. | `false` |
 
 ## Confirmation policy
 
-Do NOT ask the caller whether to proceed. Once invoked with a queue, run the cycle to
-completion. The caller (a human at the CLI or a scheduled cron) has already authorized the run
-by invoking the skill; re-prompting defeats the purpose of a background repair sweep.
+Do NOT ask the caller whether to proceed. Once invoked, resolve the explicit or config-backed
+queue and run the cycle to completion. The caller (a human at the CLI or a scheduled cron) has
+already authorized the run by invoking the skill; re-prompting defeats the purpose of a
+background repair sweep.
 
 Specifically forbidden:
 
@@ -105,8 +108,8 @@ Specifically forbidden:
 
 The only legitimate reasons to stop early:
 
-- Missing required input (no queue argument, missing project configuration). Surface the
-  missing value and exit.
+- Missing required input (no queue argument **and** no resolvable GitHub default, or missing
+  project configuration). Surface the missing value and exit.
 - The queue itself is misconfigured (Status property missing expected values, JIRA workflow
   can't reach required transitions). Surface and exit.
 - No stuck/close-out candidates, or none actionable this cycle. Exit cleanly with the idle-case
@@ -142,7 +145,7 @@ claim-and-advance). The essentials, inlined here so this skill is self-complete:
 | GitHub **repo** URL / `org/repo` (PRD namespace) | PRD (GitHub) | source=github | `in_review`, `blocked`, terminal/open PRDs, missing PRD child links, all-terminal generated-work rollups |
 | GitHub **repo** URL / `org/repo` with `tracker = github` (build namespace) | Build (GitHub) | tracker=github | `claimed`, `blocked`, terminal/open issues, parent rollups (intermediate-env + all-terminal), stale-`ready` containers |
 | GitHub **repo** URL / `org/repo` with an open issue missing configured lifecycle labels | GitHub label normalization | per classified lifecycle | add configured `prd.ready` or build `ready` |
-| Literal `github` | GitHub; route by `intake_mode` (`prd` / `build` / `both`) | per lifecycle | per lifecycle above, plus GitHub ready-label normalization |
+| Literal `github` or omitted GitHub repo when merged config resolves a GitHub source/tracker and identity | GitHub; PRD scans identity, build scans `build_queue` → merged `github.queueRepo` → identity; `both` runs those two lane-specific targets | per lifecycle | per lifecycle above, plus GitHub ready-label normalization |
 | JIRA project key or full JQL | Build (JIRA) | tracker=jira | `claimed`, `blocked`, terminal/closure verification, parent rollups (intermediate-env + all-terminal), stale-`ready` containers |
 
 Disambiguation (same as `lisa-intake`): a `notion.so`/`notion.site` URL → Notion; an Atlassian
@@ -153,6 +156,17 @@ token / literal `github` → GitHub; a bare token matching the JIRA project-key
 URL is out of scope** — this skill is batch-only; repair one item by hand via `lisa-implement`
 (build) or by re-running `lisa:<source>-to-tracker` (PRD).
 
+For GitHub `intake_mode=build` (a build-only invocation), an explicit URL or `owner/repo` wins;
+otherwise resolve `build_queue`, then local/global `github.queueRepo`, falling back to
+`github.org/github.repo`. For `intake_mode=both`, the primary `<queue>` is the PRD identity/source
+repo and `build_queue` controls the build lane, falling back through `github.queueRepo` to identity.
+A short queueRepo is normalized to `github.org`. Thus `both` is a bounded split scan: PRD candidates
+at the primary identity queue, build candidates at the resolved build queue, combined into one
+summary. Never apply both lifecycle namespaces to the umbrella repo merely because
+`github.queueRepo` is set. Repository identity remains distinct and continues to drive
+`repo:<current>` filtering, writes, and automation names. If neither an explicit queue nor a
+resolvable merged GitHub default exists, stop with the missing-input error.
+
 Role names for every vendor are resolved from `.lisa.config.json` per the `config-resolution`
 rule — never hardcode status/label strings. The relevant repair roles:
 
@@ -968,7 +982,7 @@ bucket and show compact refs plus counts.
 /schedule "every 2 hours" /lisa:repair-intake https://linear.app/acme
 /schedule "every 2 hours" /lisa:repair-intake acme/product-prds
 /schedule "every 2 hours" /lisa:repair-intake acme/frontend-v2 intake_mode=build
-/schedule "every 2 hours" /lisa:repair-intake github intake_mode=both
+/schedule "every 2 hours" /lisa:repair-intake acme/frontend intake_mode=both build_queue=acme/planning
 /schedule "every 4 hours" /lisa:repair-intake SE stale_after=12h
 /lisa:repair-intake SE stale_after=0 force=true        # manual: treat all in-progress as stalled, ignore backoff
 ```

package/plugins/lisa/skills/lisa-setup-automations/SKILL.md

@@ -59,9 +59,9 @@ report the exact conflicting path(s).
 
 | Automation | Command it runs | Cadence |
 |---|---|---|
-| **intake-repair** | `/lisa:repair-intake <queue>` | every **60 minutes** |
-| **intake-prd** | `/lisa:intake <PRD queue>` (e.g. `github intake_mode=prd`) | every **60 minutes** |
-| **intake-tickets** | `/lisa:intake <build queue>` (e.g. `github intake_mode=build`) | every **10 minutes** |
+| **intake-repair** | `/lisa:repair-intake <resolved repair queue>` (GitHub self-host example: `acme/frontend intake_mode=both build_queue=acme/planning`) | every **60 minutes** |
+| **intake-prd** | `/lisa:intake <PRD queue>` (e.g. `acme/frontend intake_mode=prd`) | every **60 minutes** |
+| **intake-tickets** | `/lisa:intake <build queue>` (e.g. `acme/planning intake_mode=build`) | every **10 minutes** |
 | **exploratory-bugs** | `/lisa-<stack>:exploratory-qa ready=<auto-start-tickets>` | **once a day** |
 | **exploratory-prds** | `/lisa:project-ideation prd_ready=<auto-start-prds>` | **once a day** |
 | **monitor** | `/lisa:monitor` | **once a day** |
@@ -75,10 +75,15 @@ lifecycle when the PRD queue has capacity," not "always create a new ready PRD."
 `/lisa:queue-status`; if pressure exists, the cycle should report the blocking role/ref and the
 smallest next action, usually `/lisa:intake <PRD queue>`, without invoking research or writing a PRD.
 
-**Queue resolution.** Resolve the intake/repair queue from `.lisa.config.json` — `source` for the
-PRD queue, `tracker` for the build queue (for the common GitHub case these are `github
-intake_mode=prd` and `github intake_mode=build`, matching how the existing Lisa intake automations
-are written).
+**Queue resolution.** Resolve the intake/repair queue from merged config — `source` for the PRD
+queue, `tracker` for the build queue. For GitHub, the PRD command uses canonical identity
+`github.org/github.repo`; the build command resolves `github.queueRepo` and falls back to that
+identity. Keep automation naming tied to the identity repo. Bake every resolved `owner/repo` into
+the scheduled commands (for example `/lisa:intake acme/frontend intake_mode=prd`,
+`/lisa:intake acme/planning intake_mode=build`, and
+`/lisa:repair-intake acme/frontend intake_mode=both build_queue=acme/planning`) so a later
+config/read-context failure cannot silently redirect the cron. A short queueRepo is normalized to
+`github.org` before writing the automation.
 
 **Naming + scope (so teardown is precise).** Name each automation with the stable prefix
 `lisa-auto-<project>-` (e.g. `lisa-auto-<project>-intake-tickets`), where `<project>` identifies this

package/plugins/lisa/skills/lisa-setup-github/SKILL.md

@@ -79,6 +79,23 @@ gh repo view "$ORG/$REPO" --json name,viewerPermission \
 
 If permission is `READ` / `TRIAGE`, stop — lisa cannot create labels or issues. Surface and exit.
 
+### Step 2b — Choose the queue repository
+
+When GitHub is selected as the destination tracker, initialize the choice from an existing
+`github.queueRepo`, or `$ORG/$REPO` when absent, then ask whether the build backlog lives there, in
+the identity repo, or in another umbrella/planning repo. If the user gives an umbrella repo, accept a short name by normalizing it to `$ORG/<name>` or accept a full
+`owner/repo`, then verify it is reachable and the authenticated identity can manage the lifecycle
+labels Lisa needs:
+
+```bash
+gh repo view "$QUEUE_ORG/$QUEUE_REPO" --json name,viewerPermission \
+  --jq 'if (.viewerPermission | IN("ADMIN","MAINTAIN","WRITE")) then "ok" else error("insufficient permission: \(.viewerPermission)") end'
+```
+
+Store `github.queueRepo` only when the canonical queue `owner/repo` differs from `$ORG/$REPO`.
+This choice changes queue scans, not repository identity: `github.repo`, `repo:<current>` claim
+scoping, issue destinations, and automation naming remain tied to the identity/tracker repo.
+
 ### Step 3 — Scaffold the lifecycle label namespaces
 
 Read role → label mappings with the same default-fallback ladder the intake skills use, so the labels created here exactly match what they look for. Only the namespaces selected in Step 0 are scaffolded.
@@ -92,12 +109,13 @@ read_role() {  # $1=namespace (build|prd) $2=role $3=default
 }
 
 # Idempotent label creator: create if missing, leave untouched if present.
+# LABEL_ORG/LABEL_REPO select the repo for the namespace being scaffolded.
 ensure_label() {  # $1=name $2=hex-color $3=description
   local name="$1" color="$2" desc="$3"
-  if gh label list --repo "$ORG/$REPO" --limit 200 --json name --jq '.[].name' | grep -qxF "$name"; then
+  if gh label list --repo "$LABEL_ORG/$LABEL_REPO" --limit 200 --json name --jq '.[].name' | grep -qxF "$name"; then
     echo "  = $name (exists)"
   else
-    gh label create "$name" --repo "$ORG/$REPO" --color "$color" --description "$desc" \
+    gh label create "$name" --repo "$LABEL_ORG/$LABEL_REPO" --color "$color" --description "$desc" \
       && echo "  + $name (created)"
   fi
 }
@@ -108,6 +126,8 @@ ensure_label() {  # $1=name $2=hex-color $3=description
 Defaults from `config-resolution`. The `done` role is **env-keyed** — create all three by default; a project whose terminal state is env-independent can later collapse `github.labels.build.done` to a single string.
 
 ```bash
+LABEL_ORG="$QUEUE_ORG"
+LABEL_REPO="$QUEUE_REPO"
 ensure_label "$(read_role build ready    status:ready)"        FBCA04 "Ready for build (human signal)"
 ensure_label "$(read_role build claimed  status:in-progress)"  0E8A16 "Build in progress (agent owns)"
 ensure_label "$(read_role build blocked  status:blocked)"      D93F0B "Blocked — human attention required"
@@ -119,6 +139,8 @@ ensure_label "$(read_role build done.production status:done)"   0E8A16 "Shipped
 #### 3b. PRD-lifecycle labels (only if GitHub is the PRD source)
 
 ```bash
+LABEL_ORG="$ORG"
+LABEL_REPO="$REPO"
 ensure_label "$(read_role prd draft     prd-draft)"            C5DEF5 "PRD in progress (product owns)"
 ensure_label "$(read_role prd ready     prd-ready)"            FBCA04 "PRD ready for ticketing"
 ensure_label "$(read_role prd in_review prd-in-review)"        5319E7 "Claude is reviewing this PRD"
@@ -145,6 +167,19 @@ jq --arg org "$ORG" --arg repo "$REPO" \
    '.github = ((.github // {}) | .org = $org | .repo = $repo)' \
    .lisa.config.json > .lisa.config.json.tmp && mv .lisa.config.json.tmp .lisa.config.json
 
+# Queue repo is canonical owner/repo and omitted for the identity/default case.
+# A source-only setup rerun preserves any existing build-queue choice.
+if [ "$GITHUB_TRACKER_SELECTED" = "true" ]; then
+  if [ "$QUEUE_ORG/$QUEUE_REPO" = "$ORG/$REPO" ]; then
+    jq 'del(.github.queueRepo)' .lisa.config.json > .lisa.config.json.tmp \
+      && mv .lisa.config.json.tmp .lisa.config.json
+  else
+    jq --arg queue "$QUEUE_ORG/$QUEUE_REPO" '.github.queueRepo = $queue' \
+      .lisa.config.json > .lisa.config.json.tmp \
+      && mv .lisa.config.json.tmp .lisa.config.json
+  fi
+fi
+
 # Conditionally write label overrides (only roles the user mapped to non-default names).
 # $LABEL_OVERRIDES_JSON is e.g. {"build":{"ready":"ready-for-dev"}} — {} if all defaults.
 if [ -n "$LABEL_OVERRIDES_JSON" ] && [ "$LABEL_OVERRIDES_JSON" != "{}" ]; then
@@ -198,8 +233,24 @@ Both are project-wide switches that change every downstream skill's default —
 
 ```bash
 jq -e '.github.org and .github.repo' .lisa.config.json >/dev/null
+EFFECTIVE_ORG=$(jq -r '.github.org // empty' .lisa.config.local.json 2>/dev/null)
+EFFECTIVE_ORG=${EFFECTIVE_ORG:-$(jq -r '.github.org' .lisa.config.json)}
+EFFECTIVE_REPO=$(jq -r '.github.repo // empty' .lisa.config.local.json 2>/dev/null)
+EFFECTIVE_REPO=${EFFECTIVE_REPO:-$(jq -r '.github.repo' .lisa.config.json)}
+QUEUE_VALUE=$(jq -r '.github.queueRepo // empty' .lisa.config.local.json 2>/dev/null)
+QUEUE_VALUE=${QUEUE_VALUE:-$(jq -r '.github.queueRepo // empty' .lisa.config.json)}
+if [ -z "$QUEUE_VALUE" ]; then
+  QUEUE_REF="$EFFECTIVE_ORG/$EFFECTIVE_REPO"
+elif [[ "$QUEUE_VALUE" == */* ]]; then
+  QUEUE_REF="$QUEUE_VALUE"
+else
+  QUEUE_REF="$EFFECTIVE_ORG/$QUEUE_VALUE"
+fi
+gh repo view "$QUEUE_REF" --json nameWithOwner --jq .nameWithOwner
 gh label list --repo "$ORG/$REPO" --limit 200 --json name --jq '.[].name' \
-  | grep -E 'status:|prd-' || true   # show the scaffolded namespaces
+  | grep -E 'prd-' || true
+gh label list --repo "$QUEUE_REF" --limit 200 --json name --jq '.[].name' \
+  | grep -E 'status:' || true
 ```
 
 If `github.projects.v2` is configured, setup verification MUST also run the shared Project utility in

package/plugins/lisa-agy/commands/lisa/agent-ready.md

@@ -1,6 +1,6 @@
 ---
-description: "Make a brownfield project agent-ready: build the initial knowledge wiki from everything the agent can reach, write wiki/gaps.md with the questions only a human can answer, and converge over re-runs (humans answer, agents absorb) until zero gaps remain. Run before letting the automation fleet operate a brownfield project unattended."
+description: "Make a brownfield project agent-ready: build the initial knowledge wiki through read-only, redacted ingestion, persist complete/partial/unavailable coverage for every source, write wiki/gaps.md with the questions only a human can answer, and converge over re-runs until every source is complete and zero gaps remain. Run before letting the automation fleet operate a brownfield project unattended."
 argument-hint: "[path]"
 ---
 
-Use the /lisa-agent-ready skill to build the initial knowledge wiki from every reachable source, write the human-answerable gaps to wiki/gaps.md, absorb any answered gaps from a prior run, and report whether the project is agent-ready or how many gaps remain. $ARGUMENTS
+Use the /lisa-agent-ready skill to build the initial knowledge wiki through read-only, redacted ingestion of every inventoried source, persist each source's complete/partial/unavailable status, write the human-answerable gaps to wiki/gaps.md, absorb any answered gaps from a prior run, and report whether every source is complete with zero gaps or what still blocks readiness. $ARGUMENTS

package/plugins/lisa-agy/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa",
-  "version": "2.223.3",
+  "version": "2.225.0",
   "description": "Universal governance — agents, skills, commands, hooks, and rules for all projects",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-agy/scripts/automation-status-expected-fleet.mjs

@@ -10,6 +10,7 @@
 
 import {
   resolveBuildQueueArgument,
+  resolveGithubQueueRepoRef,
   resolveGithubRepoRef,
   resolvePrdQueueArgument,
   resolvePrdSource,
@@ -119,9 +120,32 @@ export function resolveExpectedAutomationFleet(input = {}) {
 
   const tracker = config.tracker;
   const source = resolvePrdSource(config);
-  const prdQueue = resolvePrdQueueArgument(config, source);
-  const buildQueue = resolveBuildQueueArgument(config, tracker);
-  const repairQueue = resolveRepairQueueArgument(config, source, tracker);
+  const explicitGithubIdentity = `${identity.owner}/${identity.repo}`;
+  const githubQueue =
+    tracker === "github"
+      ? resolveGithubQueueRepoRef(config, {
+          gitRemoteUrl: input.gitRemoteUrl,
+        })
+      : null;
+  const explicitGithubQueue = githubQueue
+    ? `${githubQueue.owner}/${githubQueue.repo}`
+    : undefined;
+  const prdQueue =
+    source === "github"
+      ? `${explicitGithubIdentity} intake_mode=prd`
+      : resolvePrdQueueArgument(config, source);
+  const buildQueue = resolveBuildQueueArgument(config, tracker, {
+    explicitQueue: tracker === "github" ? explicitGithubQueue : undefined,
+    gitRemoteUrl: input.gitRemoteUrl,
+  });
+  const repairQueue = resolveRepairQueueArgument(
+    config,
+    source,
+    tracker,
+    explicitGithubIdentity,
+    explicitGithubQueue,
+    buildQueue
+  );
 
   const expected = [
     createExpectedEntry(
@@ -237,10 +261,17 @@ function createUnsupportedEntry(identity, id, reason) {
  * @param {string | undefined} tracker
  * @returns {string}
  */
-function resolveRepairQueueArgument(config, source, tracker) {
+function resolveRepairQueueArgument(
+  config,
+  source,
+  tracker,
+  explicitGithubIdentity,
+  explicitGithubQueue,
+  resolvedBuildQueue
+) {
   if (tracker === "github" && source === "github") {
     requireGithubRepo(config);
-    return "github intake_mode=both";
+    return `${explicitGithubIdentity} intake_mode=both build_queue=${explicitGithubQueue}`;
   }
 
   if (tracker === "linear" && source === "linear") {
@@ -260,13 +291,12 @@ function resolveRepairQueueArgument(config, source, tracker) {
 
   if (tracker === "github" && source === undefined) {
     requireGithubRepo(config);
-    return "github intake_mode=both";
+    return `${explicitGithubIdentity} intake_mode=both build_queue=${explicitGithubQueue}`;
   }
 
-  const buildQueue = resolveBuildQueueArgument(config, tracker);
-  return buildQueue.includes("intake_mode=")
-    ? buildQueue
-    : `${buildQueue} intake_mode=build`;
+  return resolvedBuildQueue.includes("intake_mode=")
+    ? resolvedBuildQueue
+    : `${resolvedBuildQueue} intake_mode=build`;
 }
 
 /**

package/plugins/lisa-agy/scripts/queue-contract-resolution.mjs

@@ -173,12 +173,17 @@ export function resolvePrdQueueArgument(
  */
 export function resolveBuildQueueArgument(
   config = {},
-  tracker = resolveBuildTracker(config)
+  tracker = resolveBuildTracker(config),
+  options = {}
 ) {
   switch (tracker) {
-    case "github":
-      requireGithubRepo(config);
+    case "github": {
+      const queue = resolveGithubQueueRepoRef(config, options);
+      if (options.explicitQueue || config.github?.queueRepo) {
+        return `${queue.owner}/${queue.repo} intake_mode=build`;
+      }
       return "github intake_mode=build";
+    }
     case "linear":
       requireLinearWorkspace(config);
       return "linear";
@@ -340,6 +345,14 @@ export function resolveQueueContract(input = {}) {
   const source = resolvePrdSource(config);
   const tracker = resolveBuildTracker(config);
 
+  const githubIdentity = resolveGithubRepoRef(config, input.gitRemoteUrl);
+  const githubQueue =
+    tracker === "github"
+      ? resolveGithubQueueRepoRef(config, {
+          gitRemoteUrl: input.gitRemoteUrl,
+        })
+      : null;
+
   return {
     currentRepo: resolveCurrentRepo(input),
     source,
@@ -349,7 +362,15 @@ export function resolveQueueContract(input = {}) {
       ...resolvePrdLifecycleRoles(config, source),
     },
     buildQueue: {
-      argument: resolveBuildQueueArgument(config, tracker),
+      argument: resolveBuildQueueArgument(config, tracker, {
+        gitRemoteUrl: input.gitRemoteUrl,
+      }),
+      ...(tracker === "github"
+        ? {
+            identityRepo: `${githubIdentity.owner}/${githubIdentity.repo}`,
+            queueRepo: `${githubQueue.owner}/${githubQueue.repo}`,
+          }
+        : {}),
       ...resolveBuildLifecycleRoles(config, tracker),
     },
   };
@@ -408,6 +429,54 @@ export function resolveGithubRepoRef(config = {}, gitRemoteUrl) {
   return null;
 }
 
+/**
+ * Resolve the GitHub queue without changing the repository identity used
+ * for automation names and `repo:<name>` claim scoping. An explicit invocation
+ * target wins, followed by `github.queueRepo`, then the identity repo.
+ *
+ * `github.queueRepo` may be a short repo name (normalized to the identity
+ * owner) or an `owner/repo` reference. Cross-owner queues therefore remain
+ * explicit while the common same-organization umbrella layout stays concise.
+ *
+ * @param {Record<string, any>} config
+ * @param {{ readonly explicitQueue?: string, readonly gitRemoteUrl?: string }} [options]
+ * @returns {{ readonly owner: string, readonly repo: string }}
+ */
+export function resolveGithubQueueRepoRef(config = {}, options = {}) {
+  const identity = resolveGithubRepoRef(config, options.gitRemoteUrl);
+  if (!identity) {
+    throw new Error(
+      "Unable to resolve the GitHub repository identity: github.org/github.repo or a GitHub origin remote is required."
+    );
+  }
+
+  const configured = options.explicitQueue ?? config.github?.queueRepo;
+  if (configured === undefined || configured === null || configured === "") {
+    return identity;
+  }
+  if (typeof configured !== "string") {
+    throw new Error(
+      "Unable to resolve the GitHub queue: github.queueRepo must be a repo name or owner/repo."
+    );
+  }
+
+  const value = configured
+    .trim()
+    .replace(/^https:\/\/github\.com\//i, "")
+    .replace(/\.git$/i, "");
+  const parts = value.split("/").filter(Boolean);
+  if (parts.length === 1) {
+    return { owner: identity.owner, repo: parts[0] };
+  }
+  if (parts.length === 2) {
+    return { owner: parts[0], repo: parts[1] };
+  }
+
+  throw new Error(
+    "Unable to resolve the GitHub queue: github.queueRepo must be a repo name or owner/repo."
+  );
+}
+
 /**
  * @param {string | undefined} gitRemoteUrl
  * @returns {string | null}

package/plugins/lisa-agy/scripts/queue-status-build-readers.mjs

@@ -58,23 +58,75 @@ const HIGHLIGHT_COPY = {
  *   readonly queueResolved?: boolean
  *   readonly queueArgument?: string
  *   readonly resolutionError?: string | null
+ *   readonly currentRepo?: string | null
  * }} input
  */
 export function readGithubBuildQueueSnapshot(input = {}) {
   const roles = input.roles ?? resolveBuildLifecycleRoles({}, "github").roles;
-  const normalizedItems = (input.issues ?? [])
+  const issues = input.issues ?? [];
+  const normalizedItems = issues
+    .filter(
+      issue =>
+        classifyGithubIssueRepoScope(issue, input.currentRepo) === "current"
+    )
+    .map(issue => normalizeGithubBuildIssue(issue, roles))
+    .filter(Boolean);
+  const unscopedCandidates = issues
+    .filter(
+      issue =>
+        classifyGithubIssueRepoScope(issue, input.currentRepo) === "unscoped"
+    )
     .map(issue => normalizeGithubBuildIssue(issue, roles))
     .filter(Boolean);
 
-  return createBuildQueueSnapshot({
-    tracker: "github",
-    items: normalizedItems,
-    roles,
-    namespaceAdopted: input.namespaceAdopted,
-    queueResolved: input.queueResolved,
-    queueArgument: input.queueArgument,
-    resolutionError: input.resolutionError,
-  });
+  return {
+    ...createBuildQueueSnapshot({
+      tracker: "github",
+      items: normalizedItems,
+      roles,
+      namespaceAdopted: input.namespaceAdopted,
+      queueResolved: input.queueResolved,
+      queueArgument: input.queueArgument,
+      resolutionError: input.resolutionError,
+    }),
+    unscopedCount: unscopedCandidates.length,
+    unscopedCandidates,
+  };
+}
+
+/**
+ * Classify current-repo, unlabeled, and sibling-only candidates. Unlabeled work
+ * remains separately visible because build intake must determine and stamp its
+ * repo, but it must not inflate current-repo lifecycle counts. Containers
+ * carrying multiple repo labels are current when one label matches.
+ *
+ * @param {Record<string, any>} issue
+ * @param {string | null | undefined} currentRepo
+ * @returns {"current" | "unscoped" | "sibling"}
+ */
+function classifyGithubIssueRepoScope(issue, currentRepo) {
+  if (typeof currentRepo !== "string" || currentRepo.trim().length === 0) {
+    return "current";
+  }
+
+  const repoLabels = (Array.isArray(issue?.labels) ? issue.labels : [])
+    .map(label =>
+      typeof label === "string"
+        ? label
+        : typeof label?.name === "string"
+          ? label.name
+          : ""
+    )
+    .map(label => label.trim().toLowerCase())
+    .filter(label => label.startsWith("repo:") && label.length > 5);
+
+  if (repoLabels.length === 0) {
+    return "unscoped";
+  }
+
+  return repoLabels.includes(`repo:${currentRepo.trim().toLowerCase()}`)
+    ? "current"
+    : "sibling";
 }
 
 /**