@phnx-labs/agents-cli 1.22.113 → 1.22.115

package/dist/lib/git.js

@@ -269,7 +269,7 @@ export function parseSource(source) {
     throw new Error(`Invalid source: ${source}. Supported formats: gh:owner/repo, owner/repo, github.com/owner/repo, https://github.com/owner/repo, or local path`);
 }
 /** Clone a remote repo or pull updates if it already exists locally. */
-export async function cloneOrPull(source, targetDir) {
+async function cloneOrPull(source, targetDir) {
     const git = simpleGit();
     if (source.type === 'local') {
         return { isNew: false, commit: 'local' };
@@ -313,24 +313,6 @@ export async function cloneRepo(source) {
         isNew: result.isNew,
     };
 }
-/** Clone a package from a source string into the packages directory. */
-export async function clonePackage(source) {
-    const parsed = parseSource(source);
-    if (parsed.type === 'local') {
-        return {
-            localPath: parsed.url,
-            commit: 'local',
-            isNew: false,
-        };
-    }
-    const localPath = getPackageLocalPath(source);
-    const result = await cloneOrPull(parsed, localPath);
-    return {
-        localPath,
-        commit: result.commit,
-        isNew: result.isNew,
-    };
-}
 /** Get the short commit hash (8 chars) of the latest commit in a repo. */
 export async function getRepoCommit(repoPath) {
     try {
@@ -407,64 +389,6 @@ export function resolveSnapshotSha(repoRoot) {
 export function _resetSnapshotShaCacheForTest() {
     _snapshotShaCache.clear();
 }
-/**
- * Get the current GitHub username using gh CLI.
- * Returns null if gh is not installed or user is not authenticated.
- */
-export async function getGitHubUsername() {
-    try {
-        const { exec } = await import('child_process');
-        const { promisify } = await import('util');
-        const execAsync = promisify(exec);
-        const { stdout } = await execAsync('gh api user --jq ".login"');
-        return stdout.trim() || null;
-    }
-    catch {
-        /* gh CLI not installed or not authenticated */
-        return null;
-    }
-}
-const GITHUB_USER_ENV = 'AGENTS_SHARE_GITHUB_USER';
-/** Best-effort sync read of `github.user` from git config. */
-function readGitConfigUser() {
-    try {
-        return execFileSync('git', ['config', '--global', 'github.user'], { stdio: ['ignore', 'pipe', 'ignore'] })
-            .toString()
-            .trim() || null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Resolve the GitHub username synchronously for `agents artifacts share`. Order:
- *   1. `AGENTS_SHARE_GITHUB_USER` env override
- *   2. `git config --global github.user`
- * Falls back to null so callers can decide whether to require auth or proceed
- * without a namespace.
- */
-export function resolveGitHubUsernameSync() {
-    const env = process.env[GITHUB_USER_ENV]?.trim();
-    if (env)
-        return env;
-    return readGitConfigUser();
-}
-/**
- * Resolve the GitHub username asynchronously. Order:
- *   1. `AGENTS_SHARE_GITHUB_USER` env override
- *   2. `gh api user --jq ".login"`
- *   3. `git config --global github.user`
- * Returns null if none succeed.
- */
-export async function resolveGitHubUsername() {
-    const env = process.env[GITHUB_USER_ENV]?.trim();
-    if (env)
-        return env;
-    const gh = await getGitHubUsername();
-    if (gh)
-        return gh;
-    return readGitConfigUser();
-}
 /**
  * Get the remote URL for origin in a git repo.
  */
@@ -480,16 +404,6 @@ export async function getRemoteUrl(repoPath) {
         return null;
     }
 }
-/** The repo's checked-out branch, or 'main' on a detached HEAD / read failure. */
-export async function getCurrentBranch(repoPath) {
-    try {
-        const status = await simpleGit(repoPath).status();
-        return status.current || 'main';
-    }
-    catch {
-        return 'main';
-    }
-}
 /**
  * Canonical `host/owner/repo` form of a git remote, transport-agnostic, so the
  * same repo cloned over SSH vs HTTPS compares equal. Strips protocol, any
@@ -570,36 +484,6 @@ export function sameGitRemote(a, b) {
         return false;
     return canonicalGitRemote(a) === canonicalGitRemote(b);
 }
-/**
- * Set the remote URL for origin in a git repo.
- */
-export async function setRemoteUrl(repoPath, url) {
-    const git = simpleGit(repoPath);
-    const remotes = await git.getRemotes(true);
-    const hasOrigin = remotes.some(r => r.name === 'origin');
-    if (hasOrigin) {
-        await git.remote(['set-url', 'origin', url]);
-    }
-    else {
-        await git.remote(['add', 'origin', url]);
-    }
-}
-/**
- * Check if a GitHub repo exists.
- */
-export async function checkGitHubRepoExists(owner, repo) {
-    try {
-        const { execFile } = await import('child_process');
-        const { promisify } = await import('util');
-        const execFileAsync = promisify(execFile);
-        await execFileAsync('gh', ['repo', 'view', `${owner}/${repo}`, '--json', 'name']);
-        return true;
-    }
-    catch {
-        /* repo not found or gh CLI unavailable */
-        return false;
-    }
-}
 /**
  * Commit (if dirty) and push a repo.
  *
@@ -1136,20 +1020,6 @@ export async function isSystemRepoOrigin(dir) {
         return false;
     }
 }
-/**
- * Check if repo has uncommitted changes (including untracked files).
- */
-export async function hasLocalChanges(dir) {
-    try {
-        const git = simpleGit(dir);
-        const status = await git.status();
-        return !status.isClean();
-    }
-    catch {
-        /* not a git repo */
-        return false;
-    }
-}
 /**
  * Render an absolute path in ~-relative form with forward slashes, matching the
  * way the rest of the CLI prints home-anchored paths (e.g. `~/.agents/.system`).
@@ -1587,79 +1457,12 @@ export async function getTrackedFiles(dir, subdir) {
         return [];
     }
 }
-/**
- * Check if upstream remote is configured.
- */
-export async function hasUpstreamRemote(dir) {
-    try {
-        const git = simpleGit(dir);
-        const remotes = await git.getRemotes(true);
-        return remotes.some(r => r.name === 'upstream');
-    }
-    catch {
-        /* not a git repo */
-        return false;
-    }
-}
-/**
- * Get the upstream remote fetch URL, or null if none configured.
- */
-export async function getUpstreamUrl(dir) {
-    try {
-        const git = simpleGit(dir);
-        const remotes = await git.getRemotes(true);
-        const upstream = remotes.find(r => r.name === 'upstream');
-        return upstream?.refs?.fetch ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Add or update the upstream remote.
- */
-export async function setUpstreamRemote(dir, url) {
-    const git = simpleGit(dir);
-    const remotes = await git.getRemotes(true);
-    const hasUpstream = remotes.some(r => r.name === 'upstream');
-    if (hasUpstream) {
-        await git.remote(['set-url', 'upstream', url]);
-    }
-    else {
-        await git.remote(['add', 'upstream', url]);
-    }
-}
-/**
- * Pull from upstream remote (merge updates from system repo).
- */
-export async function pullFromUpstream(dir) {
-    try {
-        const git = simpleGit(dir);
-        // Check if upstream exists
-        const remotes = await git.getRemotes(true);
-        const upstream = remotes.find(r => r.name === 'upstream');
-        if (!upstream) {
-            return { success: false, commit: '', error: 'No upstream remote configured. Run `agents fork` first.' };
-        }
-        // Fetch and merge from upstream
-        await git.fetch('upstream');
-        await git.merge(['upstream/main']);
-        const log = await git.log({ maxCount: 1 });
-        return {
-            success: true,
-            commit: log.latest?.hash.slice(0, 8) || 'unknown',
-        };
-    }
-    catch (err) {
-        return { success: false, commit: '', error: err.message };
-    }
-}
 /**
  * Try to auto-pull a git repo if it's clean and has a remote.
  * Uses --ff-only for safety (fails if diverged instead of creating merge commits).
  * Returns silently on success, returns error message on failure.
  */
-export async function tryAutoPull(dir) {
+async function tryAutoPull(dir) {
     // Must be a git repo
     if (!isGitRepo(dir)) {
         return { pulled: false };

package/dist/lib/github/gh-overload.d.ts

@@ -49,10 +49,6 @@ export declare function renderRollup(input: RollupItem[], json: boolean): string
  * forever and never posts a run, exactly what `gh pr checks` also ignores.
  */
 export declare function isSettled(rollup: RollupItem[], pendingSuites: number): boolean;
-/** Eager REST watch: poll to a terminal state, re-anchored to the live head SHA. */
-export declare function watchChecks(target: Target, json: boolean, realGh: string): Promise<number>;
-/** Lazy one-shot: real gh first; translate to REST only on the exact rate-limit signal. */
-export declare function checksOnce(target: Target | null, json: boolean, realGh: string, ghArgs: string[]): Promise<number>;
 /** Entry point for the `__gh` early branch in index.ts. */
 export declare function runGhOverload(argv: string[], cwd?: string): Promise<number>;
 export {};

package/dist/lib/github/gh-overload.js

@@ -168,7 +168,7 @@ export function isSettled(rollup, pendingSuites) {
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 /** Eager REST watch: poll to a terminal state, re-anchored to the live head SHA. */
-export async function watchChecks(target, json, realGh) {
+async function watchChecks(target, json, realGh) {
     const gh = restExec(realGh);
     const deadline = Date.now() + 30 * 60_000; // 30-min guard against a hung matrix
     let last = '';
@@ -201,7 +201,7 @@ export async function watchChecks(target, json, realGh) {
     }
 }
 /** Lazy one-shot: real gh first; translate to REST only on the exact rate-limit signal. */
-export async function checksOnce(target, json, realGh, ghArgs) {
+async function checksOnce(target, json, realGh, ghArgs) {
     // Try real gh, capturing output so we can detect the rate-limit signal.
     try {
         const { stdout } = await execFileAsync(realGh, ghArgs, { env: ghChildEnv(), maxBuffer: 16 * 1024 * 1024 });

package/dist/lib/github/project-prs.d.ts

@@ -0,0 +1,118 @@
+/**
+ * `agents projects prs <PROJECT>` — every OPEN pull request across a project's
+ * attached repositories, as one machine-readable envelope for AGI Menu.
+ *
+ * Why this exists: `agents projects status`'s `openPrs` only carries the PRs the
+ * fleet's own SESSIONS opened (the session rollup), so a project's board of open
+ * PRs — drafts, other people's PRs, anything not tied to a live session — is
+ * invisible to it. This reads the truth straight from GitHub.
+ *
+ * Design constraints (see docs conventions + the contract in
+ * `.agents/scratch/contracts-status.json`):
+ *   - Repos come ONLY from the ProjectDef's own attached slugs
+ *     ({@link projectRepoSlugs}); `--repo` is refused unless it is one of them.
+ *   - The list is REST + paginated (`gh api repos/{repo}/pulls?state=open
+ *     --paginate`), includes drafts, and applies NO author filter — it is the
+ *     whole open board, not this user's mergeable set. REST is the budget the
+ *     fleet's GraphQL poll loops do not drain (PHNX-3501).
+ *   - `checks` / `reviewDecision` are null in the list; `--number N` enriches
+ *     exactly that one PR against its live head SHA (checks via REST
+ *     {@link rollupForSha}, reviewDecision via a single lazy `gh pr view`).
+ *   - A per-repo fetch failure is reported as `repositories[].error` and flips
+ *     `partial` — it is NEVER relabeled as "zero open PRs".
+ */
+import { type GhExec } from './pr-mergeable.js';
+import { type RollupItem } from './rest.js';
+import type { ProjectDef } from '../projects.js';
+/** The author of a PR, as the menu renders it (login + avatar). */
+export interface ProjectPrAuthor {
+    login: string;
+    avatarUrl: string;
+}
+/** One open PR row. `checks`/`reviewDecision` are null unless the PR was enriched. */
+export interface ProjectPr {
+    number: number;
+    title: string;
+    url: string;
+    isDraft: boolean;
+    /** Upper-cased GitHub state — always `OPEN` here (only open PRs are listed). */
+    state: string;
+    updatedAt: string;
+    author: ProjectPrAuthor;
+    headRefName: string;
+    baseRefName: string;
+    headSha: string;
+    body: string;
+    /** Populated only for the `--number` PR: the head-SHA status-check rollup. */
+    checks: RollupItem[] | null;
+    /** Populated only for the `--number` PR: GitHub's computed review decision. */
+    reviewDecision: string | null;
+}
+/** One repository's open PRs, or the error that stopped its fetch. */
+export interface ProjectRepoPrs {
+    slug: string;
+    pullRequests: ProjectPr[];
+    /** Non-null when the fetch failed — the list is then NOT authoritative. */
+    error: string | null;
+}
+/** The full `projects prs --json` envelope. */
+export interface ProjectPrsEnvelope {
+    project: {
+        name: string;
+        linearProjectId: string | null;
+    };
+    repositories: ProjectRepoPrs[];
+    /** True when at least one repository fetch failed (its list is incomplete). */
+    partial: boolean;
+}
+/** Options for one `projects prs` run. `number` requires `repo`. */
+export interface ProjectPrsOptions {
+    /** Restrict to one attached repo (canonicalized, membership-checked). */
+    repo?: string;
+    /** Lazy detail: enrich exactly this PR's checks + reviewDecision. */
+    number?: number;
+}
+/** Build a {@link ProjectPr} from the flattened jq row. checks/reviewDecision start null. */
+export declare function rowToProjectPr(row: Record<string, unknown>): ProjectPr;
+/**
+ * Every OPEN PR for one repo, over REST, fully paginated, drafts included, no
+ * author filter. `--paginate` follows Link headers; `--jq` streams one flattened
+ * object per line so a multi-page result stays parseable.
+ */
+export declare function listOpenPrs(repo: string, gh?: GhExec): Promise<ProjectPr[]>;
+/** One PR by number, over REST (`GET repos/{repo}/pulls/{n}`). Throws if it is gone. */
+export declare function fetchOnePr(repo: string, number: number, gh?: GhExec): Promise<ProjectPr>;
+/**
+ * GitHub's computed review decision AND the PR's current head oid, from ONE lazy
+ * `gh pr view` (GraphQL). reviewDecision is deliberately NOT REST-derived: it is
+ * a branch-protection / CODEOWNERS decision REST cannot compute, and
+ * approximating it could mislead a merge decision (PHNX-3501 note). `headRefOid`
+ * rides the same call so the checks and the review verdict can be anchored to the
+ * SAME head — a PR that advanced between the REST read and this call would
+ * otherwise pair a stale check rollup with a current review. One call per
+ * `--number`, never a poll loop, so it does not drain the shared GraphQL budget.
+ */
+export declare function fetchReviewAndHead(repo: string, number: number, gh?: GhExec): Promise<{
+    reviewDecision: string | null;
+    headRefOid: string | null;
+}>;
+/**
+ * Enrich one PR with its checks + reviewDecision, both anchored to the SAME head.
+ * `gh pr view` gives the authoritative current head oid; the check rollup is run
+ * against THAT (not the possibly-staler REST head SHA), and `headSha` is updated
+ * to match, so checks and reviewDecision can never describe two different heads.
+ */
+export declare function enrichPr(repo: string, pr: ProjectPr, gh?: GhExec): Promise<ProjectPr>;
+/**
+ * Resolve which repositories a run targets, restricted to the project's own
+ * attached repos. Slugs are canonicalized (a renamed repo lists nothing under
+ * its old name — `phnx-labs/agents-cli` → `phnx-labs/agi-cli`). A `--repo` that
+ * is not one of the project's attached repos (raw or canonical) is refused.
+ */
+export declare function resolveTargetSlugs(def: ProjectDef, repo: string | undefined, gh: GhExec): Promise<string[]>;
+/**
+ * Build the full envelope. `number` (which the command requires alongside
+ * `repo`) fetches and enriches exactly that one PR; otherwise every target
+ * repo's open PRs are listed with checks/reviewDecision left null.
+ */
+export declare function buildProjectPrs(def: ProjectDef, opts?: ProjectPrsOptions, gh?: GhExec): Promise<ProjectPrsEnvelope>;

package/dist/lib/github/project-prs.js

@@ -0,0 +1,173 @@
+/**
+ * `agents projects prs <PROJECT>` — every OPEN pull request across a project's
+ * attached repositories, as one machine-readable envelope for AGI Menu.
+ *
+ * Why this exists: `agents projects status`'s `openPrs` only carries the PRs the
+ * fleet's own SESSIONS opened (the session rollup), so a project's board of open
+ * PRs — drafts, other people's PRs, anything not tied to a live session — is
+ * invisible to it. This reads the truth straight from GitHub.
+ *
+ * Design constraints (see docs conventions + the contract in
+ * `.agents/scratch/contracts-status.json`):
+ *   - Repos come ONLY from the ProjectDef's own attached slugs
+ *     ({@link projectRepoSlugs}); `--repo` is refused unless it is one of them.
+ *   - The list is REST + paginated (`gh api repos/{repo}/pulls?state=open
+ *     --paginate`), includes drafts, and applies NO author filter — it is the
+ *     whole open board, not this user's mergeable set. REST is the budget the
+ *     fleet's GraphQL poll loops do not drain (PHNX-3501).
+ *   - `checks` / `reviewDecision` are null in the list; `--number N` enriches
+ *     exactly that one PR against its live head SHA (checks via REST
+ *     {@link rollupForSha}, reviewDecision via a single lazy `gh pr view`).
+ *   - A per-repo fetch failure is reported as `repositories[].error` and flips
+ *     `partial` — it is NEVER relabeled as "zero open PRs".
+ */
+import { ghExec, canonicalizeRepo, projectRepoSlugs } from './pr-mergeable.js';
+import { rollupForSha } from './rest.js';
+/** The jq projection that flattens a REST PR object into {@link ProjectPr}'s scalars. */
+const PR_JQ = '{number, title, url: .html_url, isDraft: (.draft // false), ' +
+    'state: (.state // "" | ascii_upcase), updatedAt: (.updated_at // ""), ' +
+    'login: (.user.login // ""), avatarUrl: (.user.avatar_url // ""), ' +
+    'headRefName: (.head.ref // ""), baseRefName: (.base.ref // ""), ' +
+    'headSha: (.head.sha // ""), body: (.body // "")}';
+/** Parse newline-delimited JSON (gh `--jq` streams one object per line/page). */
+function parseNdjson(out) {
+    const rows = [];
+    for (const line of out.split('\n')) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        rows.push(JSON.parse(t));
+    }
+    return rows;
+}
+/** Build a {@link ProjectPr} from the flattened jq row. checks/reviewDecision start null. */
+export function rowToProjectPr(row) {
+    return {
+        number: Number(row.number),
+        title: String(row.title ?? ''),
+        url: String(row.url ?? ''),
+        isDraft: Boolean(row.isDraft),
+        state: String(row.state ?? ''),
+        updatedAt: String(row.updatedAt ?? ''),
+        author: { login: String(row.login ?? ''), avatarUrl: String(row.avatarUrl ?? '') },
+        headRefName: String(row.headRefName ?? ''),
+        baseRefName: String(row.baseRefName ?? ''),
+        headSha: String(row.headSha ?? ''),
+        body: String(row.body ?? ''),
+        checks: null,
+        reviewDecision: null,
+    };
+}
+/**
+ * Every OPEN PR for one repo, over REST, fully paginated, drafts included, no
+ * author filter. `--paginate` follows Link headers; `--jq` streams one flattened
+ * object per line so a multi-page result stays parseable.
+ */
+export async function listOpenPrs(repo, gh = ghExec) {
+    const out = await gh([
+        'api',
+        `repos/${repo}/pulls?state=open&per_page=100`,
+        '--paginate',
+        '--jq',
+        `.[] | ${PR_JQ}`,
+    ]);
+    return parseNdjson(out).map(rowToProjectPr);
+}
+/** One PR by number, over REST (`GET repos/{repo}/pulls/{n}`). Throws if it is gone. */
+export async function fetchOnePr(repo, number, gh = ghExec) {
+    const out = await gh(['api', `repos/${repo}/pulls/${number}`, '--jq', PR_JQ]);
+    const rows = parseNdjson(out);
+    if (rows.length === 0)
+        throw new Error(`no PR ${repo}#${number}`);
+    return rowToProjectPr(rows[0]);
+}
+/**
+ * GitHub's computed review decision AND the PR's current head oid, from ONE lazy
+ * `gh pr view` (GraphQL). reviewDecision is deliberately NOT REST-derived: it is
+ * a branch-protection / CODEOWNERS decision REST cannot compute, and
+ * approximating it could mislead a merge decision (PHNX-3501 note). `headRefOid`
+ * rides the same call so the checks and the review verdict can be anchored to the
+ * SAME head — a PR that advanced between the REST read and this call would
+ * otherwise pair a stale check rollup with a current review. One call per
+ * `--number`, never a poll loop, so it does not drain the shared GraphQL budget.
+ */
+export async function fetchReviewAndHead(repo, number, gh = ghExec) {
+    const out = (await gh([
+        'pr', 'view', String(number), '--repo', repo, '--json', 'reviewDecision,headRefOid',
+    ])).trim();
+    const parsed = out ? JSON.parse(out) : {};
+    return {
+        reviewDecision: parsed.reviewDecision || null,
+        headRefOid: parsed.headRefOid || null,
+    };
+}
+/**
+ * Enrich one PR with its checks + reviewDecision, both anchored to the SAME head.
+ * `gh pr view` gives the authoritative current head oid; the check rollup is run
+ * against THAT (not the possibly-staler REST head SHA), and `headSha` is updated
+ * to match, so checks and reviewDecision can never describe two different heads.
+ */
+export async function enrichPr(repo, pr, gh = ghExec) {
+    const { reviewDecision, headRefOid } = await fetchReviewAndHead(repo, pr.number, gh);
+    const head = headRefOid || pr.headSha;
+    const checks = await rollupForSha(repo, head, gh);
+    return { ...pr, headSha: head, checks, reviewDecision };
+}
+/**
+ * Resolve which repositories a run targets, restricted to the project's own
+ * attached repos. Slugs are canonicalized (a renamed repo lists nothing under
+ * its old name — `phnx-labs/agents-cli` → `phnx-labs/agi-cli`). A `--repo` that
+ * is not one of the project's attached repos (raw or canonical) is refused.
+ */
+export async function resolveTargetSlugs(def, repo, gh) {
+    const raw = projectRepoSlugs([def]);
+    // Canonicalize CONCURRENTLY — each `gh repo view` can take up to gh's 30s
+    // timeout, so a sequential walk of N repos would stack N×30s and blow past a
+    // native caller's bounded deadline. Repo count per project is small.
+    const canonPairs = await Promise.all(raw.map(async (slug) => [slug, await canonicalizeRepo(slug, gh)]));
+    const canon = new Map(canonPairs);
+    const canonical = [...new Set(canon.values())];
+    if (!repo)
+        return canonical;
+    const requested = await canonicalizeRepo(repo, gh);
+    const attached = raw.includes(repo) ||
+        canonical.includes(requested) ||
+        [...canon.keys()].some((k) => k === repo);
+    if (!attached) {
+        const list = raw.length ? raw.join(', ') : '(none)';
+        throw new Error(`Repo "${repo}" is not attached to project "${def.name}". Attached repos: ${list}.`);
+    }
+    return [requested];
+}
+/**
+ * Build the full envelope. `number` (which the command requires alongside
+ * `repo`) fetches and enriches exactly that one PR; otherwise every target
+ * repo's open PRs are listed with checks/reviewDecision left null.
+ */
+export async function buildProjectPrs(def, opts = {}, gh = ghExec) {
+    const project = { name: def.name, linearProjectId: def.linear?.projectId ?? null };
+    const slugs = await resolveTargetSlugs(def, opts.repo, gh);
+    // Fetch repos in PARALLEL so a native caller's overall deadline scales with the
+    // slowest repo, not the sum — a serial multi-repo walk of 30s gh calls can blow
+    // past a bounded caller timeout and lose the whole result. Repo count is small
+    // (a project's attached repos), so this is a bounded fan-out, not unbounded.
+    const repositories = await Promise.all(slugs.map(async (slug) => {
+        try {
+            let pullRequests;
+            if (opts.number !== undefined) {
+                const pr = await fetchOnePr(slug, opts.number, gh);
+                pullRequests = [await enrichPr(slug, pr, gh)];
+            }
+            else {
+                pullRequests = await listOpenPrs(slug, gh);
+            }
+            return { slug, pullRequests, error: null };
+        }
+        catch (err) {
+            // A fetch failure is reported, never relabeled as zero open PRs.
+            return { slug, pullRequests: [], error: err instanceof Error ? err.message : String(err) };
+        }
+    }));
+    const partial = repositories.some((r) => r.error !== null);
+    return { project, repositories, partial };
+}

package/dist/lib/github/rest.d.ts

@@ -27,7 +27,7 @@ export interface RollupItem extends StatusCheck {
     link?: string;
 }
 /** PR head identity — the SHA every check query must anchor to. */
-export interface PrHead {
+interface PrHead {
     number: number;
     sha: string;
 }
@@ -62,3 +62,4 @@ export declare function rollupForSha(repo: string, sha: string, gh?: GhExec): Pr
 export declare function pendingCheckSuites(repo: string, sha: string, gh?: GhExec): Promise<number>;
 /** True when gh stderr is the rate-limit outcome the shim should switch to REST on. */
 export declare function isRateLimitError(stderr: string): boolean;
+export {};

package/dist/lib/harness/exec-config-version.d.ts

@@ -1,8 +1,9 @@
 import type { AgentId } from '../types.js';
-export interface ResolvedConfigVersion {
+interface ResolvedConfigVersion {
     /** The version to pin, or null when unresolved / not installed. */
     version: string | null;
     /** The version home for that version, or null. */
     versionHome: string | null;
 }
 export declare function resolveConfigVersion(agent: AgentId, cwd: string, optionsVersion?: string): ResolvedConfigVersion;
+export {};

package/dist/lib/harness-auth-capabilities.d.ts

@@ -13,16 +13,16 @@
  * working until T4 folds connect into `accounts add`.
  */
 import type { AgentId } from './types.js';
-export type HarnessIdentityKind = 'strong' | 'email' | 'opaque';
+type HarnessIdentityKind = 'strong' | 'email' | 'opaque';
 /**
  * Durable worker credential, or `none` when the harness must log in per box.
  * Codex is both: an API key (portable, bills the API) OR a per-device
  * ChatGPT-plan device-auth login (the plan seat; never stored in the reserved
  * store because it is a rotating session).
  */
-export type HarnessWorkerKind = 'setup-token' | 'none' | `api-key:${string}` | `per-device${'' | `:${string}`}`;
-export type HarnessWorker = HarnessWorkerKind | HarnessWorkerKind[];
-export interface HarnessAuthCapability {
+type HarnessWorkerKind = 'setup-token' | 'none' | `api-key:${string}` | `per-device${'' | `:${string}`}`;
+type HarnessWorker = HarnessWorkerKind | HarnessWorkerKind[];
+interface HarnessAuthCapability {
     /** argv after the harness binary to start native login, or null when there is no finite login command. */
     login: string[] | null;
     /** argv to probe login status, or null when the CLI has no status command. */
@@ -59,3 +59,4 @@ export interface LoginInvocation {
     hint?: string;
 }
 export declare const LOGIN_INVOCATIONS: Partial<Record<AgentId, LoginInvocation>>;
+export {};

package/dist/lib/harness-connection-test.d.ts

@@ -40,7 +40,7 @@ export declare const CONNECTION_TEST_PROMPT = "say alive in one word";
  */
 export declare function classifyConnectionOutput(exitCode: number | null, output: string): ConnectionTestResult;
 /** Options for {@link runHarnessConnectionTest}. */
-export interface ConnectionTestOptions {
+interface ConnectionTestOptions {
     /** Agent-side timeout passed to `agents run --timeout`. Default `60s`. */
     timeout?: string;
     /** Hard wall-clock cap (ms) on the child, above the agent timeout. Default 90s. */
@@ -55,3 +55,4 @@ export interface ConnectionTestOptions {
  * (the request hung).
  */
 export declare function runHarnessConnectionTest(name: string, opts?: ConnectionTestOptions): Promise<ConnectionTestResult>;
+export {};