@agent-relay/factory 0.1.4 → 0.1.6

package/dist/orchestrator/factory.js

@@ -55,6 +55,8 @@ const MERGE_GATE_POLL_DELAY_MS = 10_000;
 const MAX_LABEL_IMPLEMENTERS = 4;
 const DISPATCH_FAILURE_HANDOFF_UNRESOLVED_TTL_MS = 5 * 60_000;
 const DEFAULT_LIVE_HEARTBEAT_INTERVAL_MS = 15_000;
+const REMOTE_OPERATION_PROGRESS_INTERVAL_MS = 15_000;
+const REMOTE_OPERATION_SLOW_WARN_MS = 30_000;
 const GITHUB_FACTORY_LABEL = 'factory';
 const GITHUB_MIRROR_TITLE_PREFIX = '[factory]';
 const GITHUB_MIRROR_SOURCE_PREFIX = 'Source: ';
@@ -875,54 +877,180 @@ export class FactoryLoop {
     }
     async runOnce(opts = {}) {
         const dryRun = opts.dryRun ?? this.#config.dryRun;
-        await this.#ingestGithubIssues({ dryRun });
-        const paths = await this.#readyIssuePaths();
-        const pulled = [];
-        const triaged = [];
-        const dispatched = [];
-        const skipped = [];
-        for (const path of paths) {
-            const issue = await this.#readIssue(path);
-            if (issue) {
-                await this.#recordCanonicalIssueState(issue);
-            }
-            if (!issue) {
-                continue;
-            }
-            pulled.push(issueRef(issue));
-            const dispatchBlock = await this.#dispatchBlockReason(issue);
-            if (dispatchBlock) {
-                skipped.push({ issue: issueRef(issue), reason: dispatchBlock });
-                continue;
-            }
-            const batch = await this.#batch();
-            if (batch.isInFlight(issue) || batch.isQueued(issue)) {
-                skipped.push({ issue: issueRef(issue), reason: 'already tracked' });
-                continue;
+        const startedAtMs = this.#clock.now();
+        const relayfileWaitWarningsAtStart = this.#counters.relayfileOperationWaitWarnings ?? 0;
+        const relayfileSlowOperationsAtStart = this.#counters.relayfileSlowOperations ?? 0;
+        const relayfileOperationFailuresAtStart = this.#counters.relayfileOperationFailures ?? 0;
+        this.#logger.info?.('[factory] run-once started', { dryRun });
+        let report;
+        try {
+            await this.#ingestGithubIssues({ dryRun });
+            const paths = await this.#readyIssuePaths();
+            const pulled = [];
+            const triaged = [];
+            const dispatched = [];
+            const skipped = [];
+            let lastReadyReadProgressAtMs = this.#clock.now();
+            let readyIssueReads = 0;
+            for (const path of paths) {
+                const issue = await this.#readIssue(path);
+                readyIssueReads += 1;
+                lastReadyReadProgressAtMs = this.#logTimedProgress('[factory] Linear ready issue read progress', startedAtMs, lastReadyReadProgressAtMs, { read: readyIssueReads, total: paths.length, path });
+                if (issue) {
+                    await this.#recordCanonicalIssueState(issue);
+                }
+                if (!issue) {
+                    continue;
+                }
+                pulled.push(issueRef(issue));
+                const dispatchBlock = await this.#dispatchBlockReason(issue);
+                if (dispatchBlock) {
+                    skipped.push({ issue: issueRef(issue), reason: dispatchBlock });
+                    continue;
+                }
+                const batch = await this.#batch();
+                if (batch.isInFlight(issue) || batch.isQueued(issue)) {
+                    skipped.push({ issue: issueRef(issue), reason: 'already tracked' });
+                    continue;
+                }
+                if (!this.#states.isRole(issue.stateId, 'readyForAgent')) {
+                    skipped.push({ issue: issueRef(issue), reason: 'live state is not ready-for-agent' });
+                    continue;
+                }
+                if (!isInFactoryScope(issue, this.#config.safety)) {
+                    skipped.push({ issue: issueRef(issue), reason: 'not factory-e2e scope' });
+                    continue;
+                }
+                if (!isRealLinearIssue(issue)) {
+                    skipped.push({ issue: issueRef(issue), reason: 'not reconciled real Linear issue' });
+                    continue;
+                }
+                const decision = await this.triageIssue(issue);
+                triaged.push(decision);
+                const result = await this.dispatch(decision, { dryRun });
+                if (result.agents.length === 0 && !dryRun) {
+                    skipped.push({ issue: decision.issue, reason: 'queued or escalated' });
+                }
+                else {
+                    dispatched.push(result);
+                }
             }
-            if (!this.#states.isRole(issue.stateId, 'readyForAgent')) {
-                skipped.push({ issue: issueRef(issue), reason: 'live state is not ready-for-agent' });
-                continue;
+            report = { pulled, triaged, dispatched, skipped, dryRun, slackDegraded: this.#slackDegraded };
+            return report;
+        }
+        catch (error) {
+            this.#logger.warn?.('[factory] run-once failed', {
+                dryRun,
+                elapsedMs: this.#elapsedSince(startedAtMs),
+                error: describeError(error).errorMessage,
+            });
+            throw error;
+        }
+        finally {
+            if (report) {
+                this.#logger.info?.('[factory] run-once completed', {
+                    dryRun,
+                    elapsedMs: this.#elapsedSince(startedAtMs),
+                    readyIssues: report.pulled.length,
+                    triaged: report.triaged.length,
+                    dispatched: report.dispatched.length,
+                    skipped: report.skipped.length,
+                    slackDegraded: report.slackDegraded ?? false,
+                    relayfileWaitWarnings: (this.#counters.relayfileOperationWaitWarnings ?? 0) - relayfileWaitWarningsAtStart,
+                    relayfileSlowOperations: (this.#counters.relayfileSlowOperations ?? 0) - relayfileSlowOperationsAtStart,
+                    relayfileOperationFailures: (this.#counters.relayfileOperationFailures ?? 0) - relayfileOperationFailuresAtStart,
+                });
             }
-            if (!isInFactoryScope(issue, this.#config.safety)) {
-                skipped.push({ issue: issueRef(issue), reason: 'not factory-e2e scope' });
-                continue;
+        }
+    }
+    async #listRelayfileTree(prefix, phase) {
+        return this.#withRelayfileOperation('listTree', { phase, prefix }, () => this.#mount.listTree(prefix), {
+            count: (paths) => paths.length,
+            logFailure: true,
+            logStart: true,
+            logComplete: true,
+        });
+    }
+    async #ensureRelayfileSubRoot(prefix, phase, opts) {
+        return this.#withRelayfileOperation('ensureSubRoot', { phase, prefix }, () => this.#mount.ensureSubRoot(prefix, opts), {
+            logFailure: true,
+            logStart: true,
+            logComplete: true,
+        });
+    }
+    async #readRelayfileFile(path, phase) {
+        return this.#withRelayfileOperation('readFile', { phase, path }, () => this.#mount.readFile(path));
+    }
+    async #withRelayfileOperation(operation, details, fn, opts = {}) {
+        const startedAtMs = this.#clock.now();
+        const metadata = { operation, ...details };
+        let waitWarnings = 0;
+        if (opts.logStart) {
+            this.#logger.info?.(`[factory] relayfile ${operation} started`, metadata);
+        }
+        const progressTimer = this.#logger.warn
+            ? setInterval(() => {
+                waitWarnings += 1;
+                this.#increment('relayfileOperationWaitWarnings');
+                this.#logger.warn?.('[factory] relayfile operation still waiting on relayfile cloud', {
+                    ...metadata,
+                    elapsedMs: this.#elapsedSince(startedAtMs),
+                });
+            }, REMOTE_OPERATION_PROGRESS_INTERVAL_MS)
+            : undefined;
+        if (progressTimer) {
+            progressTimer.unref?.();
+        }
+        try {
+            const result = await fn();
+            const elapsedMs = this.#elapsedSince(startedAtMs);
+            const count = opts.count?.(result);
+            if (opts.logComplete) {
+                this.#logger.info?.(`[factory] relayfile ${operation} completed`, {
+                    ...metadata,
+                    elapsedMs,
+                    ...(count === undefined ? {} : { count }),
+                });
             }
-            if (!isRealLinearIssue(issue)) {
-                skipped.push({ issue: issueRef(issue), reason: 'not reconciled real Linear issue' });
-                continue;
+            if (waitWarnings === 0 && elapsedMs >= REMOTE_OPERATION_SLOW_WARN_MS) {
+                this.#increment('relayfileSlowOperations');
+                this.#logger.warn?.('[factory] relayfile operation was slow', {
+                    ...metadata,
+                    elapsedMs,
+                });
             }
-            const decision = await this.triageIssue(issue);
-            triaged.push(decision);
-            const result = await this.dispatch(decision, { dryRun });
-            if (result.agents.length === 0 && !dryRun) {
-                skipped.push({ issue: decision.issue, reason: 'queued or escalated' });
+            return result;
+        }
+        catch (error) {
+            if (opts.logFailure || waitWarnings > 0) {
+                this.#increment('relayfileOperationFailures');
+                this.#logger.warn?.('[factory] relayfile operation failed', {
+                    ...metadata,
+                    elapsedMs: this.#elapsedSince(startedAtMs),
+                    error: describeError(error).errorMessage,
+                });
             }
-            else {
-                dispatched.push(result);
+            throw error;
+        }
+        finally {
+            if (progressTimer) {
+                clearInterval(progressTimer);
             }
         }
-        return { pulled, triaged, dispatched, skipped, dryRun, slackDegraded: this.#slackDegraded };
+    }
+    #elapsedSince(startedAtMs) {
+        return Math.max(0, this.#clock.now() - startedAtMs);
+    }
+    #logTimedProgress(message, startedAtMs, lastLoggedAtMs, metadata) {
+        const now = this.#clock.now();
+        if (now - lastLoggedAtMs < REMOTE_OPERATION_PROGRESS_INTERVAL_MS) {
+            return lastLoggedAtMs;
+        }
+        this.#logger.info?.(message, {
+            ...metadata,
+            elapsedMs: Math.max(0, now - startedAtMs),
+        });
+        return now;
     }
     async runLoop(opts = {}) {
         const maxIterations = Math.min(5, Math.max(1, Math.trunc(opts.maxIterations ?? this.#config.loop.maxIterations)));
@@ -1220,7 +1348,7 @@ export class FactoryLoop {
         if (this.#githubIngestionEnabled !== undefined) {
             return this.#githubIngestionEnabled;
         }
-        const githubReady = await this.#mount.ensureSubRoot(GITHUB_ISSUE_ROOT, { timeoutMs: 90_000 });
+        const githubReady = await this.#ensureRelayfileSubRoot(GITHUB_ISSUE_ROOT, 'GitHub issue ingestion readiness', { timeoutMs: 90_000 });
         this.#githubIngestionEnabled = githubReady === 'ready';
         if (!this.#githubIngestionEnabled) {
             this.#logger.warn?.(`[factory] ${GITHUB_ISSUE_ROOT} sub-root is not mounted; GitHub issue ingestion disabled`);
@@ -1231,13 +1359,25 @@ export class FactoryLoop {
         if (!await this.#ensureGithubIngestionReady()) {
             return;
         }
+        const startedAtMs = this.#clock.now();
+        this.#logger.info?.('[factory] GitHub issue ingestion started', { dryRun: opts.dryRun ?? false });
         // Load the existing Linear mirror candidates once for the whole pass so
         // dedupe stays O(N + M) reads instead of re-scanning ISSUE_ROOT for every
         // GitHub issue (gemini perf finding on #findGithubIssueMirror).
         const candidates = this.#newMirrorCandidateCache();
-        for (const path of await this.#githubIssuePaths()) {
+        const paths = await this.#githubIssuePaths();
+        let processed = 0;
+        let lastProgressAtMs = this.#clock.now();
+        for (const path of paths) {
             await this.#handleGithubIssueChange(path, { ...opts, candidates });
+            processed += 1;
+            lastProgressAtMs = this.#logTimedProgress('[factory] GitHub issue ingestion progress', startedAtMs, lastProgressAtMs, { processed, total: paths.length, path });
         }
+        this.#logger.info?.('[factory] GitHub issue ingestion completed', {
+            dryRun: opts.dryRun ?? false,
+            elapsedMs: this.#elapsedSince(startedAtMs),
+            issues: paths.length,
+        });
     }
     // Lazily lists+reads ISSUE_ROOT mirror candidates at most once, then memoizes
     // them for reuse across every GitHub issue handled in the same pass.
@@ -1253,40 +1393,53 @@ export class FactoryLoop {
         };
     }
     async #loadLinearMirrorCandidates() {
+        const startedAtMs = this.#clock.now();
+        this.#logger.info?.('[factory] Linear mirror candidate loading started');
         const candidates = [];
-        for (const path of await this.#mount.listTree(ISSUE_ROOT)) {
+        let scanned = 0;
+        let lastProgressAtMs = startedAtMs;
+        for (const path of await this.#listRelayfileTree(ISSUE_ROOT, 'GitHub mirror candidate loading')) {
             if (!isLinearIssueMirrorCandidatePath(path)) {
                 continue;
             }
+            scanned += 1;
             const issue = await this.#readIssue(path);
             if (issue) {
                 candidates.push(issue);
             }
+            lastProgressAtMs = this.#logTimedProgress('[factory] Linear mirror candidate loading progress', startedAtMs, lastProgressAtMs, { scanned, candidates: candidates.length, path });
         }
+        this.#logger.info?.('[factory] Linear mirror candidate loading completed', {
+            elapsedMs: this.#elapsedSince(startedAtMs),
+            scanned,
+            candidates: candidates.length,
+        });
         return candidates;
     }
     async #githubIssuePaths() {
         try {
-            const paths = await this.#mount.listTree(GITHUB_ISSUE_ROOT);
-            const issuePaths = [];
-            for (const path of paths) {
-                if (githubIssuePathParts(path) !== undefined) {
-                    issuePaths.push(path);
-                }
-                else if (githubIssueDirectoryPathParts(path) !== undefined) {
-                    // listTree returns the issue directory entry alongside its
-                    // meta.json file; githubIssuePathParts() already collected the
-                    // file, so skip the directory to avoid reading the same issue
-                    // twice in one backfill pass. Directory paths are only meaningful
-                    // for live change events, not the tree scan.
-                    continue;
-                }
-                else if (isGithubIssueTreePath(path)) {
-                    this.#increment('githubIssuesIgnoredByPathRegex');
-                    this.#logger.debug?.('[factory] ignored GitHub issue path with unsupported relayfile shape', { path });
+            const issuePaths = new Set();
+            for (const root of githubIssueScanRoots(this.#config)) {
+                const paths = await this.#listRelayfileTree(root, 'GitHub issue ingestion');
+                for (const path of paths) {
+                    if (githubIssuePathParts(path) !== undefined) {
+                        issuePaths.add(path);
+                    }
+                    else if (githubIssueDirectoryPathParts(path) !== undefined) {
+                        // listTree returns the issue directory entry alongside its
+                        // meta.json file; githubIssuePathParts() already collected the
+                        // file, so skip the directory to avoid reading the same issue
+                        // twice in one backfill pass. Directory paths are only meaningful
+                        // for live change events, not the tree scan.
+                        continue;
+                    }
+                    else if (isGithubIssueTreePath(path)) {
+                        this.#increment('githubIssuesIgnoredByPathRegex');
+                        this.#logger.debug?.('[factory] ignored GitHub issue path with unsupported relayfile shape', { path });
+                    }
                 }
             }
-            return issuePaths.sort();
+            return [...issuePaths].sort();
         }
         catch (error) {
             this.#increment('githubIssueListFailures');
@@ -1351,7 +1504,7 @@ export class FactoryLoop {
         try {
             for (const candidatePath of candidatePaths) {
                 try {
-                    const { content } = await this.#mount.readFile(candidatePath);
+                    const { content } = await this.#readRelayfileFile(candidatePath, 'GitHub issue ingestion');
                     return parseGithubIssue(candidatePath, content);
                 }
                 catch (error) {
@@ -1374,7 +1527,7 @@ export class FactoryLoop {
     async #findGithubIssueMirror(ghIssue, candidates) {
         const draftPath = githubIssueMirrorDraftPath(ghIssue);
         try {
-            return parseLinearIssue(draftPath, (await this.#mount.readFile(draftPath)).content);
+            return parseLinearIssue(draftPath, (await this.#readRelayfileFile(draftPath, 'GitHub issue mirror lookup')).content);
         }
         catch {
             // The draft path only exists before the Linear provider reconciles the
@@ -1599,14 +1752,14 @@ export class FactoryLoop {
     async #readyIssuePaths() {
         const pathsByKey = new Map();
         const canonicalPathsByKey = new Map();
-        for (const path of await this.#mount.listTree(ISSUE_ROOT)) {
+        for (const path of await this.#listRelayfileTree(ISSUE_ROOT, 'Linear ready issue canonical discovery')) {
             if (isIssueFilePath(path)) {
                 const key = keyFromPath(path);
                 canonicalPathsByKey.set(key, path);
                 pathsByKey.set(key, path);
             }
         }
-        for (const path of await this.#mount.listTree(linearByStatePath('ready-for-agent'))) {
+        for (const path of await this.#listRelayfileTree(linearByStatePath('ready-for-agent'), 'Linear ready issue alias discovery')) {
             if (isIssueAliasFilePath(path)) {
                 const canonicalPath = canonicalPathsByKey.get(keyFromPath(path));
                 if (canonicalPath) {
@@ -1626,7 +1779,9 @@ export class FactoryLoop {
             // /linear/issues/<key>__<uuid>.json path (no state/url/team); the full
             // record lands at the by-id / by-uuid aliases. Read the canonical sibling
             // when the primary parses empty so triage sees real state.
-            const issue = await readLinearIssueWithCanonicalFallback(this.#mount, path);
+            const issue = await readLinearIssueWithCanonicalFallback({
+                readFile: (candidatePath) => this.#readRelayfileFile(candidatePath, 'Linear canonical issue read'),
+            }, path);
             // Synced Linear records may carry only the state NAME, not the state UUID
             // (relayfile-adapters#205). The factory matches state by UUID, so backfill
             // the id from the name when the payload omitted it — otherwise every issue
@@ -2293,10 +2448,9 @@ export class FactoryLoop {
         if (!snapshot) {
             return;
         }
-        // Map the PR to an in-flight issue by its head ref (reuses the existing
-        // key matcher; no branch-naming assumption).
-        const headRef = snapshot.headRef ?? '';
-        const record = (await this.#batch()).inFlight.find((candidate) => !candidate.dryRun && headRef && containsIssueKey(headRef, candidate.issue.key));
+        // Map the PR to an in-flight issue using the same precedence as the
+        // post-merge path: branch name first, then title/body issue references.
+        const record = this.#inFlightIssueForPrSnapshot(snapshot, await this.#batch());
         if (prMetaShowsMerged(snapshot)) {
             await this.#advanceMergedPrToDone(snapshot, record);
             return;
@@ -2316,6 +2470,19 @@ export class FactoryLoop {
         }
         await this.#ensureBabysitter(record, { repo: `${parts.owner}/${parts.repo}`, prNumber: snapshot.number, url: snapshot.url, path });
     }
+    #inFlightIssueForPrSnapshot(snapshot, batch) {
+        let best;
+        for (const record of batch.inFlight) {
+            if (record.dryRun) {
+                continue;
+            }
+            const score = prSnapshotIssueMatchScore(snapshot, record.issue.key);
+            if (score > 0 && (!best || score > best.score)) {
+                best = { record, score };
+            }
+        }
+        return best?.record;
+    }
     async #advanceMergedPrToDone(snapshot, record) {
         if (record) {
             await this.#completeIssue(record, { targetState: 'done', runMergeGate: false, completionReason: 'pr-merged' });
@@ -3403,6 +3570,21 @@ function dispatchSpecs(decision) {
 function labelDerivedDispatchDecision(liveIssue, decision, config) {
     const routesByLabel = labelRoutesForIssue(liveIssue, config);
     if (routesByLabel.labels.length === 0) {
+        const githubMirrorRoute = githubMirrorRouteForIssue(liveIssue, config);
+        if (githubMirrorRoute) {
+            const implementer = routeImplementerSpec(liveIssue, config, githubMirrorRoute.slug, githubMirrorRoute.route);
+            return {
+                ok: true,
+                decision: {
+                    ...decision,
+                    routes: [githubMirrorRoute.route],
+                    scope: 'single',
+                    implementers: [implementer],
+                    workflow: undefined,
+                    reviewer: routeReviewerSpec(liveIssue, config, githubMirrorRoute.route, decision.reviewer),
+                },
+            };
+        }
         // No repo labels — which is also what a label-less sync produces
         // (relayfile-adapters#205, labels dropped from the synced record). Fall back
         // to the configured default repo (consistent with triage, which already
@@ -3479,6 +3661,49 @@ function labelDerivedDispatchDecision(liveIssue, decision, config) {
         },
     };
 }
+function githubMirrorRouteForIssue(issue, config) {
+    const repo = githubMirrorRepoForIssue(issue);
+    if (!repo) {
+        return undefined;
+    }
+    const entry = findLabelRoute(config.repos.byLabel, repo)
+        ?? findLabelRoute(config.repos.byLabel, repo.split('/').at(-1) ?? repo);
+    if (!entry) {
+        return undefined;
+    }
+    return {
+        slug: entry.label,
+        route: {
+            repo: entry.repo,
+            clonePath: config.repos.clonePaths[entry.repo],
+            rationale: `GitHub mirror source ${repo} routes to ${entry.repo}.`,
+        },
+    };
+}
+function githubMirrorRepoForIssue(issue) {
+    const payload = wrappedPayload(issue.raw);
+    const source = asRecord(payload.source);
+    if (stringValue(source?.provider)?.toLowerCase() === 'github') {
+        const owner = stringValue(source?.owner);
+        const repo = stringValue(source?.repo);
+        if (owner && repo) {
+            return `${owner}/${repo}`;
+        }
+        const urlRepo = githubRepoFromUrl(stringValue(source?.url));
+        if (urlRepo) {
+            return urlRepo;
+        }
+    }
+    const sourceUrlLine = issue.description
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .find((line) => line.startsWith(GITHUB_MIRROR_SOURCE_PREFIX));
+    return githubRepoFromUrl(sourceUrlLine?.slice(GITHUB_MIRROR_SOURCE_PREFIX.length));
+}
+function githubRepoFromUrl(url) {
+    const match = url?.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)\/issues\/\d+(?:[/?#].*)?$/iu);
+    return match?.[1] && match[2] ? `${match[1]}/${match[2]}` : undefined;
+}
 function labelRoutesForIssue(issue, config) {
     const labels = uniqueNormalizedLabels(issue.labels).filter((label) => !isShapeLabel(label));
     const routes = [];
@@ -3710,22 +3935,26 @@ const githubIssueDirectoryPathParts = (path) => {
 };
 const githubIssueHasFactoryLabel = (issue) => issue.labels.some((label) => label.toLowerCase() === GITHUB_FACTORY_LABEL);
 const githubIssueIsClosed = (issue) => issue.state === 'closed';
-const githubIssueMirrorPayload = (issue, repoLabel, config, readyForAgentStateId) => ({
-    id: githubIssueMirrorId(issue),
-    title: `${GITHUB_MIRROR_TITLE_PREFIX} ${issue.title}`.trim(),
-    description: githubIssueMirrorDescription(issue),
-    stateId: readyForAgentStateId,
-    labels: [{ name: repoLabel }],
-    team: { key: config.safety.requireTeamKey },
-    source: {
-        provider: 'github',
-        owner: issue.owner,
-        repo: issue.repoName,
-        number: issue.number,
-        url: issue.url,
-        path: issue.path,
-    },
-});
+const githubIssueMirrorPayload = (issue, repoLabel, config, readyForAgentStateId) => {
+    const teamId = config.linear.teamIds[config.safety.requireTeamKey];
+    return {
+        id: githubIssueMirrorId(issue),
+        title: `${GITHUB_MIRROR_TITLE_PREFIX} ${issue.title}`.trim(),
+        description: githubIssueMirrorDescription(issue),
+        stateId: readyForAgentStateId,
+        labels: [{ name: repoLabel }],
+        ...(teamId ? { teamId } : {}),
+        team: { key: config.safety.requireTeamKey, ...(teamId ? { id: teamId } : {}) },
+        source: {
+            provider: 'github',
+            owner: issue.owner,
+            repo: issue.repoName,
+            number: issue.number,
+            url: issue.url,
+            path: issue.path,
+        },
+    };
+};
 const githubIssueMirrorDescription = (issue) => {
     const body = issue.body.trim();
     const source = `${GITHUB_MIRROR_SOURCE_PREFIX}${issue.url}`;
@@ -3830,6 +4059,27 @@ const reposFromConfig = (config) => {
     ].filter((repo) => Boolean(repo)));
     return [...repos];
 };
+const githubIssueScanRoots = (config) => {
+    const roots = new Set([GITHUB_ISSUE_ROOT]);
+    for (const repo of reposFromConfig(config)) {
+        const parts = githubRepoParts(repo);
+        if (!parts)
+            continue;
+        roots.add(`/github/repos/${parts.owner}__${parts.repo}/issues/by-id`);
+    }
+    return [...roots];
+};
+const githubRepoParts = (repo) => {
+    const split = repo.match(/^([^/]+)\/([^/]+)$/u);
+    if (split) {
+        return { owner: split[1], repo: split[2] };
+    }
+    const compact = repo.match(/^([^/]+)__([^/]+)$/u);
+    if (compact) {
+        return { owner: compact[1], repo: compact[2] };
+    }
+    return undefined;
+};
 const githubPullRoot = (repo) => {
     const [owner, name] = repo.split('/');
     return owner && name ? `/github/repos/${owner}__${name}/pulls/by-id/` : `/github/repos/${repo}/pulls/by-id/`;