@phnx-labs/agents-cli 1.20.91 → 1.20.93

package/dist/lib/project-probe.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Project workspace probing — the drift signal behind `projects status --fleet`.
+ *
+ * Projects are natively multi-device: the same definition (home-relative paths)
+ * re-roots on every fleet machine, and the question is whether the project's
+ * repos are PRESENT on each box, on which branch, how far ahead/behind their
+ * upstream, and whether they carry uncommitted changes. This module is the pure
+ * local half: given a set of home-relative paths it probes each one with a
+ * handful of read-only git calls. Drift is measured against the LAST-FETCHED
+ * upstream (`@{upstream}`) — deliberately no `git fetch`, so a probe is fast
+ * and offline-safe. The fleet half (`--fleet`) just runs this probe on every
+ * peer via the canonical `remote-agents-json` SSH fan-out.
+ */
+import type { ProjectDef } from './projects.js';
+/** The on-disk state of one workspace repo on one machine. */
+export interface RepoWorkspaceStatus {
+    /** The probed path, echoed home-relative (re-roots per machine). */
+    path: string;
+    /** `.git` exists (a directory, or a FILE for a linked worktree). */
+    present: boolean;
+    branch?: string;
+    /** The configured upstream ref (e.g. `origin/main`); absent → no upstream. */
+    upstream?: string;
+    /** Commits on HEAD not on the upstream. Undefined without an upstream. */
+    ahead?: number;
+    /** Commits on the upstream not on HEAD. Undefined without an upstream. */
+    behind?: number;
+    /** Uncommitted (incl. untracked) paths from `git status --porcelain`. */
+    dirty?: number;
+    /** ISO 8601 committer date of HEAD. */
+    lastCommit?: string;
+    /** `.git` exists but git could not read it — never looks silently clean. */
+    error?: string;
+}
+/** A probe result tagged with the machine that answered (the fleet view). */
+export interface HostWorkspaceStatus extends RepoWorkspaceStatus {
+    host: string;
+}
+/**
+ * Probe one workspace repo. A missing path yields `{present: false}` and no
+ * git call is made. On a present repo every signal is best-effort: whatever
+ * succeeded is reported, and a repo whose `.git` exists yet every git call
+ * failed surfaces as present-with-error rather than silently clean.
+ */
+export declare function probeRepoWorkspace(absPath: string): RepoWorkspaceStatus;
+/** Probe each home-relative path (expanded against the local home), in order. */
+export declare function probeProjectWorkspaces(paths: string[]): RepoWorkspaceStatus[];
+/**
+ * The home-relative paths to probe for a project definition: its `root` plus
+ * each `repos[].path` (the opt-in for additional repos), deduped. Every target
+ * is normalized through the same `toHomeRelative(expandLocalHome(...))` the
+ * probe echoes, so a hand-edited def (absolute path under home, trailing
+ * slash) matches its probe rows exactly — `writeProjectDef` normalizes on
+ * write, but defs are hand-editable YAML and never silently drop a row.
+ */
+export declare function workspaceTargetsForDef(def: ProjectDef): string[];
+/**
+ * Parse a peer's `projects probe --json` stdout, tagging each row with the
+ * machine that answered. Defensive against version skew / partial output, the
+ * same boundary contract as `parseRemoteActive`: non-JSON or a non-array
+ * yields `[]`, and rows without a `path`/`present` core are dropped.
+ */
+export declare function parseRemoteProbe(stdout: string, machine: string): HostWorkspaceStatus[];
+/**
+ * One workspace's compact state: `✓ clean · main`, `⚠ 12 dirty · ↑3 ↓1 ·
+ * feature/x`, `✗ missing`, or `⚠ error: …`. Pure — chalk styling only.
+ */
+export declare function formatWorkspaceLine(s: RepoWorkspaceStatus): string;
+/**
+ * The fleet view of one project's workspaces: one content line per probed
+ * path (host-sorted `host: state` cells joined by ` · `), labelled with the
+ * path when a project probes more than one. Pure — the caller adds the
+ * `fleet` row label.
+ */
+export declare function formatFleetWorkspaces(statuses: HostWorkspaceStatus[]): string[];

package/dist/lib/project-probe.js

@@ -0,0 +1,160 @@
+/**
+ * Project workspace probing — the drift signal behind `projects status --fleet`.
+ *
+ * Projects are natively multi-device: the same definition (home-relative paths)
+ * re-roots on every fleet machine, and the question is whether the project's
+ * repos are PRESENT on each box, on which branch, how far ahead/behind their
+ * upstream, and whether they carry uncommitted changes. This module is the pure
+ * local half: given a set of home-relative paths it probes each one with a
+ * handful of read-only git calls. Drift is measured against the LAST-FETCHED
+ * upstream (`@{upstream}`) — deliberately no `git fetch`, so a probe is fast
+ * and offline-safe. The fleet half (`--fleet`) just runs this probe on every
+ * peer via the canonical `remote-agents-json` SSH fan-out.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { execFileSync } from 'child_process';
+import chalk from 'chalk';
+import { expandLocalHome, toHomeRelative } from './project-root.js';
+/** Per-call git budget. A read-only git call taking >3s is wedged by any
+ * definition (NFS stall, index lock) — and the fleet fan-out SIGKILLs the SSH
+ * hop at 12s, so a probe must fit inside that budget to avoid a slow peer
+ * being misreported as unreachable: 3s × 5 calls leaves headroom even when
+ * one repo is genuinely stuck. */
+const GIT_TIMEOUT_MS = 3_000;
+/** One read-only git call against `absPath`; undefined on any failure. */
+function git(absPath, args) {
+    try {
+        return execFileSync('git', ['-C', absPath, ...args], {
+            encoding: 'utf8',
+            timeout: GIT_TIMEOUT_MS,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Probe one workspace repo. A missing path yields `{present: false}` and no
+ * git call is made. On a present repo every signal is best-effort: whatever
+ * succeeded is reported, and a repo whose `.git` exists yet every git call
+ * failed surfaces as present-with-error rather than silently clean.
+ */
+export function probeRepoWorkspace(absPath) {
+    const status = { path: toHomeRelative(absPath), present: false };
+    if (!fs.existsSync(path.join(absPath, '.git')))
+        return status;
+    status.present = true;
+    const branch = git(absPath, ['rev-parse', '--abbrev-ref', 'HEAD']);
+    const upstream = git(absPath, ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}']);
+    // `--left-right --count A...B` prints "<left>\t<right>" — left is
+    // upstream-only (we are BEHIND by that much), right is HEAD-only (AHEAD).
+    const counts = upstream !== undefined
+        ? git(absPath, ['rev-list', '--left-right', '--count', '@{upstream}...HEAD'])
+        : undefined;
+    const dirtyOut = git(absPath, ['status', '--porcelain']);
+    const lastCommit = git(absPath, ['log', '-1', '--format=%cI']);
+    if (branch === undefined && dirtyOut === undefined && lastCommit === undefined) {
+        status.error = '.git exists but git could not read this repo';
+        return status;
+    }
+    if (branch !== undefined)
+        status.branch = branch;
+    if (upstream !== undefined)
+        status.upstream = upstream;
+    if (counts !== undefined) {
+        const [behind, ahead] = counts.split(/\s+/).map(Number);
+        if (Number.isFinite(behind) && Number.isFinite(ahead)) {
+            status.behind = behind;
+            status.ahead = ahead;
+        }
+    }
+    if (dirtyOut !== undefined)
+        status.dirty = dirtyOut === '' ? 0 : dirtyOut.split('\n').length;
+    if (lastCommit !== undefined)
+        status.lastCommit = lastCommit;
+    return status;
+}
+/** Probe each home-relative path (expanded against the local home), in order. */
+export function probeProjectWorkspaces(paths) {
+    return paths.map((p) => probeRepoWorkspace(expandLocalHome(p)));
+}
+/**
+ * The home-relative paths to probe for a project definition: its `root` plus
+ * each `repos[].path` (the opt-in for additional repos), deduped. Every target
+ * is normalized through the same `toHomeRelative(expandLocalHome(...))` the
+ * probe echoes, so a hand-edited def (absolute path under home, trailing
+ * slash) matches its probe rows exactly — `writeProjectDef` normalizes on
+ * write, but defs are hand-editable YAML and never silently drop a row.
+ */
+export function workspaceTargetsForDef(def) {
+    const targets = [def.root, ...(def.repos ?? []).map((r) => r.path)]
+        .filter((p) => typeof p === 'string' && p.length > 0)
+        .map((p) => toHomeRelative(expandLocalHome(p)));
+    return [...new Set(targets)];
+}
+/**
+ * Parse a peer's `projects probe --json` stdout, tagging each row with the
+ * machine that answered. Defensive against version skew / partial output, the
+ * same boundary contract as `parseRemoteActive`: non-JSON or a non-array
+ * yields `[]`, and rows without a `path`/`present` core are dropped.
+ */
+export function parseRemoteProbe(stdout, machine) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    return parsed.flatMap((x) => {
+        if (x && typeof x === 'object' && !Array.isArray(x)) {
+            const o = x;
+            if (typeof o.path === 'string' && typeof o.present === 'boolean') {
+                return [{ ...o, host: machine }];
+            }
+        }
+        return [];
+    });
+}
+/**
+ * One workspace's compact state: `✓ clean · main`, `⚠ 12 dirty · ↑3 ↓1 ·
+ * feature/x`, `✗ missing`, or `⚠ error: …`. Pure — chalk styling only.
+ */
+export function formatWorkspaceLine(s) {
+    if (!s.present)
+        return chalk.red('✗ missing');
+    if (s.error)
+        return chalk.yellow(`⚠ error: ${s.error}`);
+    const parts = [];
+    if (s.dirty !== undefined && s.dirty > 0)
+        parts.push(`${s.dirty} dirty`);
+    const drift = [
+        s.ahead !== undefined && s.ahead > 0 ? `↑${s.ahead}` : '',
+        s.behind !== undefined && s.behind > 0 ? `↓${s.behind}` : '',
+    ].filter(Boolean).join(' ');
+    if (drift)
+        parts.push(drift);
+    const head = parts.length > 0 ? chalk.yellow(`⚠ ${parts.join(' · ')}`) : chalk.green('✓ clean');
+    return s.branch ? `${head} ${chalk.dim('·')} ${s.branch}` : head;
+}
+/**
+ * The fleet view of one project's workspaces: one content line per probed
+ * path (host-sorted `host: state` cells joined by ` · `), labelled with the
+ * path when a project probes more than one. Pure — the caller adds the
+ * `fleet` row label.
+ */
+export function formatFleetWorkspaces(statuses) {
+    const paths = [...new Set(statuses.map((s) => s.path))];
+    const multi = paths.length > 1;
+    return paths.map((p) => {
+        const rows = statuses
+            .filter((s) => s.path === p)
+            .sort((a, b) => a.host.localeCompare(b.host));
+        const body = rows.map((r) => `${chalk.cyan(r.host)}: ${formatWorkspaceLine(r)}`).join(chalk.dim('  ·  '));
+        return multi ? `${chalk.dim(`${p} · `)}${body}` : body;
+    });
+}

package/dist/lib/project-resources.d.ts

@@ -5,3 +5,11 @@ export interface ProjectResourceSyncResult {
 }
 export declare function projectAgentRoot(projectRoot: string, agent: AgentId): string;
 export declare function syncProjectResourcesToAgent(agent: AgentId, version: string, projectAgentsDir: string): ProjectResourceSyncResult;
+/**
+ * One human line for the files a project sync left alone because you already
+ * wrote them. This is the normal steady state — every sync of a project whose
+ * `.claude/commands/` you hand-authored hits it — so it is a single grouped
+ * line, not one wrapped warning per file, and it says "yours" rather than the
+ * internal "user-owned". Returns null when nothing was skipped.
+ */
+export declare function formatKeptProjectResources(skipped: string[]): string | null;

package/dist/lib/project-resources.js

@@ -127,9 +127,37 @@ function record(kind, name, relPaths, result, manifestPaths) {
         manifestPaths.add(toPosixRel(rel));
 }
 function skip(dest, projectRoot, result) {
-    const rel = path.relative(projectRoot, dest);
-    result.skipped.push(rel);
-    console.warn(`Skipping project resource target ${rel}: already exists and is user-owned`);
+    result.skipped.push(path.relative(projectRoot, dest));
+}
+/**
+ * One human line for the files a project sync left alone because you already
+ * wrote them. This is the normal steady state — every sync of a project whose
+ * `.claude/commands/` you hand-authored hits it — so it is a single grouped
+ * line, not one wrapped warning per file, and it says "yours" rather than the
+ * internal "user-owned". Returns null when nothing was skipped.
+ */
+export function formatKeptProjectResources(skipped) {
+    if (skipped.length === 0)
+        return null;
+    const rels = [...skipped].sort((a, b) => a.localeCompare(b)).map(toPosixRel);
+    if (rels.length === 1)
+        return `Kept your existing ${rels[0]}`;
+    const byDir = new Map();
+    for (const rel of rels) {
+        const dir = rel.includes('/') ? rel.slice(0, rel.lastIndexOf('/')) : '.';
+        const names = byDir.get(dir) ?? [];
+        names.push(rel.slice(rel.lastIndexOf('/') + 1));
+        byDir.set(dir, names);
+    }
+    if (byDir.size === 1) {
+        const [dir, names] = [...byDir.entries()][0];
+        const PREVIEW = 3;
+        const preview = names.slice(0, PREVIEW).join(', ');
+        const more = names.length > PREVIEW ? `, +${names.length - PREVIEW} more` : '';
+        return `Kept ${rels.length} of your own files in ${dir}: ${preview}${more}`;
+    }
+    const dirs = [...byDir.entries()].map(([dir, names]) => `${dir} (${names.length})`).join(', ');
+    return `Kept ${rels.length} of your own files in ${dirs}`;
 }
 function syncProjectCommands(agent, version, projectAgentsDir, agentRoot, result, manifestPaths) {
     const cfg = AGENTS[agent];

package/dist/lib/project-root.js

@@ -17,6 +17,7 @@ import * as fs from 'fs';
 import { readMeta, updateMeta } from './state.js';
 import { getMainRepoRoot } from './git.js';
 import { toPosix } from './platform/index.js';
+import { loadProjectDef, resolveDefinedProjectPath } from './projects.js';
 const HOME = process.env.HOME ?? os.homedir();
 /** Rewrite an absolute path under the local home to a `~/`-relative string; pass others through. */
 export function toHomeRelative(abs) {
@@ -124,6 +125,21 @@ export function buildProjectPath(root, ref, forRemote) {
  * absolute local path and verifies it exists (so a mistyped slug fails loudly).
  */
 export async function resolveProjectRef(ref, opts) {
+    const { slug, worktree } = parseProjectRef(ref);
+    if (!slug)
+        throw new Error(`Invalid --project value: "${ref}"`);
+    // Definition first: a named project in ~/.agents/projects/<slug>.yaml overrides
+    // the <root>/<slug> convention. Absent (or root-less) → fall through unchanged.
+    const def = loadProjectDef(slug);
+    if (def) {
+        const fromDef = resolveDefinedProjectPath(def, worktree, opts.forRemote);
+        if (fromDef) {
+            if (!opts.forRemote && !fs.existsSync(fromDef)) {
+                throw new Error(`Project path not found: ${fromDef} (defined in ${slug}.yaml)`);
+            }
+            return fromDef;
+        }
+    }
     const cwd = opts.cwd ?? process.cwd();
     const root = await ensureProjectRoot(cwd);
     const resolved = buildProjectPath(root, ref, opts.forRemote);

package/dist/lib/project-status.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Project-level progress rollup — the headline of the projects subsystem.
+ *
+ * At 50–100 agents the per-agent activity line is noise; what matters is the
+ * PROJECT. This aggregates the signals already carried per session (status,
+ * plan progress, open PRs, tickets, worktrees) into one row per project, keyed
+ * by matching each session's cwd to a defined project root (`projectNameForCwd`).
+ * The session set is whatever the caller passes (today `getActiveSessions()` —
+ * this machine's live view, matched by local-home cwd; a fleet-wide fan-out is a
+ * deferred follow-up). Pure over an `ActiveSession[]` so the aggregation is
+ * unit-testable; the merged-PR signal IS repo-global (harvested via `gh`) and the
+ * artifact signal is local, both added in `enrichProjectSignals`.
+ */
+import type { ActiveSession, ActiveStatus } from './session/active.js';
+import { type ProjectDef } from './projects.js';
+/** One live agent on a project — the WHO behind the byStatus count. */
+export interface ProjectMember {
+    /** Harness name (claude / codex / …), from the session's `kind`. */
+    agent: string;
+    /** Lifecycle status (running / idle / …). */
+    status: string;
+    /** Tracker ticket the session is tied to, when any. */
+    ticket?: string;
+    /** Machine the session runs on (provenance host / fleet peer), when known. */
+    host?: string;
+}
+/** One project's live session rollup. */
+export interface ProjectSessionRollup {
+    name: string;
+    /** Total sessions whose cwd is inside this project. */
+    agents: number;
+    /** Count per lifecycle status. */
+    byStatus: Partial<Record<ActiveStatus, number>>;
+    /** Which agents are on the project (one per matched session). */
+    members: ProjectMember[];
+    /** Summed checklist progress across this project's sessions. */
+    plan: {
+        done: number;
+        total: number;
+    };
+    /** Distinct open PRs held by this project's sessions. */
+    openPrs: {
+        url: string;
+        number?: number;
+    }[];
+    /** Distinct tickets worked or created by this project's sessions. */
+    tickets: string[];
+    /** Sessions running inside a worktree. */
+    worktrees: number;
+}
+/**
+ * Roll active sessions up by project. Returns a map keyed by project name,
+ * containing only projects with at least one matched session — callers merge
+ * with the full definition list to show zero-agent projects.
+ */
+export declare function rollupSessionsByProject(defs: ProjectDef[], sessions: ActiveSession[]): Map<string, ProjectSessionRollup>;
+/** Plan completion percentage (0–100), or undefined when nothing is tracked. */
+export declare function planPct(plan: {
+    done: number;
+    total: number;
+}): number | undefined;
+/** Sort members for the card: running first, then idle, then the rest; agent name asc within a state. */
+export declare function sortProjectMembers(members: ProjectMember[]): ProjectMember[];
+/** Cap for the members line before it collapses to `+N more`. */
+export declare const MEMBERS_LINE_LIMIT = 6;
+/**
+ * The `agents` line under `live`: one cell per DISTINCT member state —
+ * `claude · running · RUSH-2107 @zion` — with identical cells collapsed to a
+ * `×N` count (35 same-harness sessions in one state are one fact, not six
+ * truncated duplicates), capped at {@link MEMBERS_LINE_LIMIT} cells with a
+ * `+N more` tail counting members, not cells. Pure (chalk styling only); the
+ * caller adds the label.
+ */
+export declare function formatProjectMembers(members: ProjectMember[], limit?: number): string;
+/** Harvested signals not on the session list: repo-global merged PRs + releases, local artifacts, in a time window. */
+export interface ProjectRemoteSignals {
+    windowDays: number;
+    /** PRs merged into the primary repo within the window (via `gh`). */
+    mergedPrs: number;
+    /** Artifacts agents produced within the window (activity.created milestones). */
+    artifacts: number;
+    /** Basename of the most recent artifact, when any. */
+    lastArtifact?: string;
+    /** Latest release of the PRIMARY repo (via `gh release list`), when any. */
+    latestRelease?: {
+        tag: string;
+        publishedAt: string;
+    };
+}
+/**
+ * Harvest the signals that don't live on the active-session list: recently
+ * merged PRs (from GitHub via `gh`) and artifacts agents produced (from the
+ * local activity-milestone log, matched to the project by cwd). Best-effort —
+ * a missing `gh`, no auth, or no repo degrades to zero rather than throwing, so
+ * `projects status` still renders. `nowMs` is injected for testability.
+ */
+export declare function enrichProjectSignals(def: ProjectDef, windowDays: number, nowMs: number, opts?: {
+    activityRoot?: string;
+    skipRemote?: boolean;
+}): Promise<ProjectRemoteSignals>;

package/dist/lib/project-status.js

@@ -0,0 +1,182 @@
+/**
+ * Project-level progress rollup — the headline of the projects subsystem.
+ *
+ * At 50–100 agents the per-agent activity line is noise; what matters is the
+ * PROJECT. This aggregates the signals already carried per session (status,
+ * plan progress, open PRs, tickets, worktrees) into one row per project, keyed
+ * by matching each session's cwd to a defined project root (`projectNameForCwd`).
+ * The session set is whatever the caller passes (today `getActiveSessions()` —
+ * this machine's live view, matched by local-home cwd; a fleet-wide fan-out is a
+ * deferred follow-up). Pure over an `ActiveSession[]` so the aggregation is
+ * unit-testable; the merged-PR signal IS repo-global (harvested via `gh`) and the
+ * artifact signal is local, both added in `enrichProjectSignals`.
+ */
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import chalk from 'chalk';
+import { projectNameForCwd } from './projects.js';
+import { readRecentActivity } from './activity.js';
+const execFileAsync = promisify(execFile);
+function blank(name) {
+    return {
+        name,
+        agents: 0,
+        byStatus: {},
+        members: [],
+        plan: { done: 0, total: 0 },
+        openPrs: [],
+        tickets: [],
+        worktrees: 0,
+    };
+}
+/**
+ * Roll active sessions up by project. Returns a map keyed by project name,
+ * containing only projects with at least one matched session — callers merge
+ * with the full definition list to show zero-agent projects.
+ */
+export function rollupSessionsByProject(defs, sessions) {
+    const map = new Map();
+    const prSeen = new Map();
+    const ticketSeen = new Map();
+    for (const s of sessions) {
+        const name = projectNameForCwd(s.cwd, defs);
+        if (!name)
+            continue;
+        let r = map.get(name);
+        if (!r) {
+            r = blank(name);
+            map.set(name, r);
+            prSeen.set(name, new Set());
+            ticketSeen.set(name, new Set());
+        }
+        r.agents++;
+        r.byStatus[s.status] = (r.byStatus[s.status] ?? 0) + 1;
+        const member = { agent: s.kind, status: s.status };
+        if (s.ticket?.id)
+            member.ticket = s.ticket.id;
+        if (s.machine)
+            member.host = s.machine;
+        r.members.push(member);
+        if (s.todos) {
+            r.plan.done += s.todos.done;
+            r.plan.total += s.todos.total;
+        }
+        if (s.pr?.url && !prSeen.get(name).has(s.pr.url)) {
+            prSeen.get(name).add(s.pr.url);
+            r.openPrs.push({ url: s.pr.url, number: s.pr.number });
+        }
+        const tset = ticketSeen.get(name);
+        for (const t of [s.ticket?.id, ...(s.createdTickets ?? [])]) {
+            if (t && !tset.has(t)) {
+                tset.add(t);
+                r.tickets.push(t);
+            }
+        }
+        if (s.worktree)
+            r.worktrees++;
+    }
+    return map;
+}
+/** Plan completion percentage (0–100), or undefined when nothing is tracked. */
+export function planPct(plan) {
+    if (plan.total <= 0)
+        return undefined;
+    return Math.round((plan.done / plan.total) * 100);
+}
+/**
+ * Display order for the members line: the states a human scans for first
+ * (running, then idle, then need-input, then queued), everything else after,
+ * status name then agent name ascending within a state.
+ */
+const MEMBER_STATUS_RANK = { running: 0, idle: 1, input_required: 2, queued: 3 };
+/** Sort members for the card: running first, then idle, then the rest; agent name asc within a state. */
+export function sortProjectMembers(members) {
+    return [...members].sort((a, b) => {
+        const ra = MEMBER_STATUS_RANK[a.status] ?? 4;
+        const rb = MEMBER_STATUS_RANK[b.status] ?? 4;
+        if (ra !== rb)
+            return ra - rb;
+        if (ra === 4 && a.status !== b.status)
+            return a.status.localeCompare(b.status);
+        return a.agent.localeCompare(b.agent);
+    });
+}
+/** Cap for the members line before it collapses to `+N more`. */
+export const MEMBERS_LINE_LIMIT = 6;
+/**
+ * The `agents` line under `live`: one cell per DISTINCT member state —
+ * `claude · running · RUSH-2107 @zion` — with identical cells collapsed to a
+ * `×N` count (35 same-harness sessions in one state are one fact, not six
+ * truncated duplicates), capped at {@link MEMBERS_LINE_LIMIT} cells with a
+ * `+N more` tail counting members, not cells. Pure (chalk styling only); the
+ * caller adds the label.
+ */
+export function formatProjectMembers(members, limit = MEMBERS_LINE_LIMIT) {
+    if (members.length === 0)
+        return '';
+    // Collapse identical cells — 35 same-harness sessions in the same state are
+    // one fact (`claude · running ×16`), not six truncated duplicates.
+    const counts = new Map();
+    for (const m of sortProjectMembers(members)) {
+        const parts = [m.agent, m.status];
+        if (m.ticket)
+            parts.push(m.ticket);
+        const cell = parts.join(' · ') + (m.host ? ` @${m.host}` : '');
+        const key = cell.toLowerCase();
+        const entry = counts.get(key);
+        if (entry)
+            entry.n++;
+        else
+            counts.set(key, { cell, n: 1 });
+    }
+    const entries = [...counts.values()];
+    const shown = entries.slice(0, Math.max(1, limit));
+    const shownMembers = shown.reduce((acc, e) => acc + e.n, 0);
+    const more = members.length - shownMembers;
+    const cells = shown.map(({ cell, n }) => (n > 1 ? `${cell} ×${n}` : cell));
+    return cells.join(chalk.dim('  ·  ')) + (more > 0 ? chalk.dim(`  ·  +${more} more`) : '');
+}
+/**
+ * Harvest the signals that don't live on the active-session list: recently
+ * merged PRs (from GitHub via `gh`) and artifacts agents produced (from the
+ * local activity-milestone log, matched to the project by cwd). Best-effort —
+ * a missing `gh`, no auth, or no repo degrades to zero rather than throwing, so
+ * `projects status` still renders. `nowMs` is injected for testability.
+ */
+export async function enrichProjectSignals(def, windowDays, nowMs, opts = {}) {
+    const sinceMs = nowMs - windowDays * 86_400_000;
+    const out = { windowDays, mergedPrs: 0, artifacts: 0 };
+    try {
+        const evs = readRecentActivity({ events: ['artifact.created'], sinceMs, root: opts.activityRoot });
+        const mine = evs.filter((e) => projectNameForCwd(e.cwd, [def]) === def.name);
+        out.artifacts = mine.length;
+        if (mine.length && typeof mine[0].detail === 'string')
+            out.lastArtifact = mine[0].detail;
+    }
+    catch {
+        /* activity log unreadable — best-effort */
+    }
+    if (def.repo && !opts.skipRemote) {
+        try {
+            const { stdout } = await execFileAsync('gh', ['pr', 'list', '--repo', def.repo, '--state', 'merged', '--json', 'number,mergedAt', '--limit', '100'], { timeout: 8000, encoding: 'utf8' });
+            const rows = JSON.parse(stdout);
+            out.mergedPrs = rows.filter((r) => r.mergedAt && Date.parse(r.mergedAt) >= sinceMs).length;
+        }
+        catch {
+            /* gh missing / unauthenticated / repo not found — skip this signal */
+        }
+        // Latest release of the PRIMARY repo only (repos[] is deliberately not
+        // scanned — one release line per card). Same best-effort degradation.
+        try {
+            const { stdout } = await execFileAsync('gh', ['release', 'list', '-R', def.repo, '-L', '1', '--json', 'tagName,publishedAt'], { timeout: 8000, encoding: 'utf8' });
+            const rows = JSON.parse(stdout);
+            const first = rows[0];
+            if (first?.tagName)
+                out.latestRelease = { tag: first.tagName, publishedAt: first.publishedAt ?? '' };
+        }
+        catch {
+            /* gh missing / unauthenticated / repo has no releases — skip this signal */
+        }
+    }
+    return out;
+}