@phnx-labs/agents-cli 1.22.72 → 1.22.74

package/dist/lib/project-resources.js

@@ -1,3 +1,4 @@
+import { execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import { AGENTS, agentConfigDirName, isAgentHardDeprecated } from './agents.js';
@@ -39,10 +40,14 @@ export function syncProjectResourcesToAgent(agent, version, projectAgentsDir) {
         // .agents/{commands,skills,…}, refreshed on every launch. Left untracked it
         // dirties `git status` and can block `git merge`/`checkout` when a stray
         // commit of the same path collides. So the generator owns its ignore rule:
-        // reconcile a per-agent marker block in <projectRoot>/.gitignore listing
-        // exactly the paths it manages. Passing the manifest set (empty when a sync
-        // clears a harness) also prunes the block. See PHNX-3717.
-        reconcileProjectGitignore(projectRoot, agent, agentRoot, Array.from(next).sort());
+        // reconcile a per-agent marker block listing exactly the paths it manages.
+        // That block lives in `.git/info/exclude` — git's per-clone, uncommitted
+        // ignore file — NOT the tracked `.gitignore`: these entries are never
+        // committed upstream, so writing them into `.gitignore` left every launch
+        // with a permanent `M .gitignore` that blocked `git pull` (PHNX-3718).
+        // Passing the manifest set (empty when a sync clears a harness) also prunes
+        // the block. See PHNX-3717 for the self-managed-ignore feature.
+        reconcileManagedIgnore(projectRoot, agent, agentRoot, Array.from(next).sort());
     }
     return result;
 }
@@ -75,7 +80,11 @@ function gitignoreMarkers(agent) {
 }
 /**
  * Turn the manifest's managed paths (relative to agentRoot) into anchored,
- * POSIX, projectRoot-relative `.gitignore` entries. Two guards keep it honest:
+ * POSIX, `referenceRoot`-relative ignore entries. `referenceRoot` is the
+ * directory the anchored `/…` patterns resolve against — the git worktree root
+ * for a `.git/info/exclude` block, since git anchors info/exclude patterns at
+ * the top of the working tree (not at the harness dir). Two guards keep it
+ * honest:
  *   - drop any path that escapes the harness config dir (e.g. grok writes
  *     commands back into the tracked `.agents/` tree via a `../` subdir —
  *     ignoring that would hide tracked source; separate bug, PHNX-3718);
@@ -84,7 +93,7 @@ function gitignoreMarkers(agent) {
  *     these never masks a hand-authored or committed file (e.g. a repo that
  *     commits its own `.claude/CLAUDE.md` keeps it — it is not in the manifest).
  */
-export function managedGitignoreEntries(agentRoot, projectRoot, managed) {
+export function managedGitignoreEntries(agentRoot, referenceRoot, managed) {
     const root = path.resolve(agentRoot);
     const entries = new Set();
     for (const rel of managed) {
@@ -93,31 +102,63 @@ export function managedGitignoreEntries(agentRoot, projectRoot, managed) {
         const abs = path.resolve(agentRoot, rel);
         if (abs !== root && !abs.startsWith(root + path.sep))
             continue;
-        const fromProject = toPosixRel(path.relative(projectRoot, abs));
-        if (!fromProject || fromProject === '..' || fromProject.startsWith('../'))
+        const fromRoot = toPosixRel(path.relative(referenceRoot, abs));
+        if (!fromRoot || fromRoot === '..' || fromRoot.startsWith('../'))
             continue;
-        entries.add('/' + fromProject);
+        entries.add('/' + fromRoot);
     }
     return Array.from(entries).sort();
 }
-/** True when `dir` is inside a git working tree — walks up to the filesystem
- *  root looking for a `.git` entry. `projectRoot` (the parent of the resolved
- *  `.agents/` dir) is not guaranteed to be the git root: a monorepo subdir can
- *  carry its own `.agents/` while `.git` lives several levels up. A root-only
- *  check would silently no-op the whole feature there. */
-function isInsideGitRepo(dir) {
-    let cur = path.resolve(dir);
-    for (;;) {
-        if (pathExists(path.join(cur, '.git')))
-            return true;
-        const parent = path.dirname(cur);
-        if (parent === cur)
-            return false;
-        cur = parent;
+/**
+ * Ask git where the local, per-clone ignore file lives and where the worktree
+ * top is, resolved robustly for every layout by delegating to git itself:
+ *   - normal repo → `<root>/.git/info/exclude`;
+ *   - monorepo subdir → the same file even when `.git` is several levels up
+ *     (`projectRoot`, the parent of `.agents/`, is not the git root);
+ *   - linked worktree / submodule → `.git` is a FILE (`gitdir: …`), and
+ *     `--git-path info/exclude` resolves to the shared COMMON dir so the block
+ *     applies across every worktree.
+ * `--path-format=absolute` forces absolute paths regardless of the `-C` cwd.
+ * One `git rev-parse` yields both paths (exclude path first, worktree root
+ * second), so the launch path spawns git ONCE, not twice.
+ * Returns null when `dir` is not inside a git repo (git exits non-zero), which
+ * fails the feature open (no-op) exactly like the old in-tree check did.
+ */
+function resolveGitExcludeTarget(dir) {
+    try {
+        const out = execFileSync('git', ['-C', dir, 'rev-parse', '--path-format=absolute', '--git-path', 'info/exclude', '--show-toplevel'], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+        const [excludePath, worktreeRoot] = out.split('\n').map((l) => l.trim());
+        if (!excludePath || !worktreeRoot)
+            return null;
+        // Fail open on anything that isn't a clean pair of ABSOLUTE paths. A git
+        // older than 2.31 (predates `--path-format`) echoes the unrecognized flag
+        // back on stdout instead of erroring, which would otherwise shift the parse
+        // and have mkdirSync create a stray `--path-format=absolute` dir. The
+        // absolute-path check turns that into a clean no-op.
+        if (!path.isAbsolute(excludePath) || !path.isAbsolute(worktreeRoot))
+            return null;
+        return { excludePath, worktreeRoot };
+    }
+    catch {
+        return null;
+    }
+}
+/** True when git tracks `absPath` in the repo `dir` sits in. */
+function isTrackedByGit(dir, absPath) {
+    try {
+        execFileSync('git', ['-C', dir, 'ls-files', '--error-unmatch', '--', absPath], {
+            stdio: ['ignore', 'ignore', 'ignore'],
+        });
+        return true;
+    }
+    catch {
+        return false;
     }
 }
 /**
- * Apply this agent's managed block to `.gitignore` content, IN PLACE.
+ * Apply this agent's managed block to ignore-file content, IN PLACE — used both
+ * to write the block into `.git/info/exclude` and to strip a leftover block from
+ * a legacy tracked `.gitignore` (entries `[]` prunes).
  *
  * In-place replacement (not strip-then-append) is load-bearing: appending would
  * move this agent's block behind every other agent's block on each resync, so in
@@ -141,9 +182,11 @@ function applyManagedBlock(content, begin, end, entries) {
         if (entries.length > 0) {
             return [...lines.slice(0, bi), begin, ...entries, end, ...lines.slice(ei + 1)].join('\n');
         }
-        // Prune the block, tidying the blank lines that hugged it. Vestigial on the
-        // reconcileProjectGitignore path (its entries always include the manifest,
-        // so entries.length is never 0 there) — kept for a direct caller/unit test.
+        // Prune the block, tidying the blank lines that hugged it. Unreached on the
+        // reconcileManagedIgnore write path (its entries always include the manifest,
+        // so entries.length is never 0 there), but the load-bearing case for
+        // stripLegacyManagedGitignoreBlock, which calls with entries=[] to migrate a
+        // leftover block out of the tracked .gitignore.
         const before = lines.slice(0, bi);
         const after = lines.slice(ei + 1);
         while (before.length && before[before.length - 1].trim() === '')
@@ -160,30 +203,42 @@ function applyManagedBlock(content, begin, end, entries) {
     return body.length > 0 ? `${body}\n\n${block}\n` : `${block}\n`;
 }
 /**
- * Reconcile a per-agent managed block in `<projectRoot>/.gitignore` so the
- * generated per-harness resource dir never shows as untracked dirt. Idempotent
- * and convergent: replaces the block in place and writes only when the content
- * actually changes, so the launch hot path does not churn the file (or its
- * watchers) every run — even in a project synced by several harnesses. When a
- * sync clears a harness's resources the block does not vanish: it shrinks to the
- * lone `.agents-managed.json` entry (that file still sits in the harness dir and
- * must stay ignored), so the block is only ever fully pruned by hand, never via
- * this call path. Never creates a `.gitignore` outside a git working tree.
+ * Reconcile a per-agent managed block in `.git/info/exclude` so the generated
+ * per-harness resource dir never shows as untracked dirt — WITHOUT dirtying the
+ * tracked `.gitignore`. Idempotent and convergent: replaces the block in place
+ * and writes only when the content actually changes, so the launch hot path does
+ * not churn the file (or its watchers) every run — even in a project synced by
+ * several harnesses. When a sync clears a harness's resources the block does not
+ * vanish: it shrinks to the lone `.agents-managed.json` entry (that file still
+ * sits in the harness dir and must stay ignored), so the block is only ever
+ * fully pruned by hand, never via this call path. Fails open (no-op) outside a
+ * git working tree.
+ *
+ * Also self-heals repos dirtied by the previous behavior: PHNX-3717 wrote these
+ * blocks into `<projectRoot>/.gitignore`, which is never committed upstream, so
+ * every launch left a permanent `M .gitignore` that blocked `git pull`
+ * (PHNX-3718). `stripLegacyManagedGitignoreBlock` removes this agent's leftover
+ * block from that tracked file on the next launch, cleaning the diff instead of
+ * stranding it.
  */
-function reconcileProjectGitignore(projectRoot, agent, agentRoot, managed) {
-    const gitignorePath = path.join(projectRoot, '.gitignore');
-    if (!isInsideGitRepo(projectRoot) && !pathExists(gitignorePath))
-        return;
+function reconcileManagedIgnore(projectRoot, agent, agentRoot, managed) {
+    // Migrate away from the old tracked-.gitignore location first, so an already
+    // dirtied repo cleans itself even if git resolution below fails.
+    stripLegacyManagedGitignoreBlock(projectRoot, agent);
+    const target = resolveGitExcludeTarget(projectRoot);
+    if (!target)
+        return; // not a git repo — fail open
     const { begin, end } = gitignoreMarkers(agent);
     // Ignore the manifest marker file too, not just the synced resources: the
     // sync always writes `<agentRoot>/.agents-managed.json`, so without this the
     // harness dir still shows as untracked in `git status` on the strength of that
     // one file (defeating the whole point). It lives at agentRoot, so it resolves
-    // through the same anchoring + escape guard as any managed path.
-    const entries = managedGitignoreEntries(agentRoot, projectRoot, [MANIFEST_FILE, ...managed]);
+    // through the same anchoring + escape guard as any managed path. Anchored to
+    // the worktree root, since info/exclude patterns resolve against the tree top.
+    const entries = managedGitignoreEntries(agentRoot, target.worktreeRoot, [MANIFEST_FILE, ...managed]);
     let original = '';
     try {
-        original = fs.readFileSync(gitignorePath, 'utf-8');
+        original = fs.readFileSync(target.excludePath, 'utf-8');
     }
     catch {
         original = '';
@@ -191,8 +246,42 @@ function reconcileProjectGitignore(projectRoot, agent, agentRoot, managed) {
     const next = applyManagedBlock(original, begin, end, entries);
     if (next === null || next === original)
         return;
-    const tmp = gitignorePath + '.tmp';
+    fs.mkdirSync(path.dirname(target.excludePath), { recursive: true }); // create info/ if missing
+    const tmp = target.excludePath + '.tmp';
     fs.writeFileSync(tmp, next);
+    fs.renameSync(tmp, target.excludePath);
+}
+/**
+ * Remove this agent's leftover managed block from a tracked `<projectRoot>/
+ * .gitignore` written by the pre-PHNX-3718 behavior. Strips ONLY the fenced
+ * block (leaving every hand-written rule untouched), never creates the file,
+ * and never touches a `.gitignore` that carries no block of ours. If stripping
+ * empties a file we created (its only content was our block), the empty file is
+ * removed when git does not track it — an empty untracked `.gitignore` would
+ * still read as `?? .gitignore` dirt, the very thing this migration clears.
+ */
+function stripLegacyManagedGitignoreBlock(projectRoot, agent) {
+    const gitignorePath = path.join(projectRoot, '.gitignore');
+    let original;
+    try {
+        original = fs.readFileSync(gitignorePath, 'utf-8');
+    }
+    catch {
+        return; // no .gitignore — nothing to migrate
+    }
+    const { begin, end } = gitignoreMarkers(agent);
+    // Empty entries → applyManagedBlock prunes the block; returns `original`
+    // unchanged when there is no block, or null on an orphaned begin marker
+    // (which we refuse to touch rather than truncate the user's rules).
+    const stripped = applyManagedBlock(original, begin, end, []);
+    if (stripped === null || stripped === original)
+        return;
+    if (stripped === '' && !isTrackedByGit(projectRoot, gitignorePath)) {
+        removePath(gitignorePath);
+        return;
+    }
+    const tmp = gitignorePath + '.tmp';
+    fs.writeFileSync(tmp, stripped);
     fs.renameSync(tmp, gitignorePath);
 }
 function removeManagedPath(agentRoot, rel) {

package/dist/lib/rush-session.d.ts

@@ -2,8 +2,16 @@
  * Rush session freshness — the ONE judgment shared by every consumer of
  * ~/.rush/user.yaml (cloud dispatch, cloud session source, secrets sync driver).
  *
- * A Rush session stores `expires_at` as Unix seconds. Two values mean "never
- * expires" and MUST NOT be read as an absolute timestamp:
+ * A Rush session stores `expires_at` as Unix MILLISECONDS — the same unit
+ * rush/cli writes and reads it in (`sessionTokenFresh` in auth_reader.go compares
+ * against `time.Now()...UnixMilli()`), and the same unit the JWT `exp` claim maps
+ * to (`exp * 1000`). So freshness must compare it against `Date.now()` (ms), NOT
+ * `Date.now() / 1000` (seconds). Comparing ms against seconds was PHNX-3805: a
+ * long-expired session (e.g. `expires_at: 1788157222000`) read as `1.788e12 <=
+ * 1.788e9` → always false → never expired, so `agents cloud providers` reported
+ * Rush `available: true` on a dead session and every dispatch failed with a 401.
+ *
+ * Two values mean "never expires" and MUST NOT be read as an absolute timestamp:
  *   - `0`         — an opaque Phoenix `pid_` bearer written by `rush login`;
  *                   `0` = non-expiring by contract (mirrors rush/cli's isFresh,
  *                   the same fix RUSH-1310 landed for the daemon-less freshness

package/dist/lib/rush-session.js

@@ -2,8 +2,16 @@
  * Rush session freshness — the ONE judgment shared by every consumer of
  * ~/.rush/user.yaml (cloud dispatch, cloud session source, secrets sync driver).
  *
- * A Rush session stores `expires_at` as Unix seconds. Two values mean "never
- * expires" and MUST NOT be read as an absolute timestamp:
+ * A Rush session stores `expires_at` as Unix MILLISECONDS — the same unit
+ * rush/cli writes and reads it in (`sessionTokenFresh` in auth_reader.go compares
+ * against `time.Now()...UnixMilli()`), and the same unit the JWT `exp` claim maps
+ * to (`exp * 1000`). So freshness must compare it against `Date.now()` (ms), NOT
+ * `Date.now() / 1000` (seconds). Comparing ms against seconds was PHNX-3805: a
+ * long-expired session (e.g. `expires_at: 1788157222000`) read as `1.788e12 <=
+ * 1.788e9` → always false → never expired, so `agents cloud providers` reported
+ * Rush `available: true` on a dead session and every dispatch failed with a 401.
+ *
+ * Two values mean "never expires" and MUST NOT be read as an absolute timestamp:
  *   - `0`         — an opaque Phoenix `pid_` bearer written by `rush login`;
  *                   `0` = non-expiring by contract (mirrors rush/cli's isFresh,
  *                   the same fix RUSH-1310 landed for the daemon-less freshness
@@ -20,5 +28,6 @@ export function isRushSessionExpired(expiresAt) {
     // `0` (non-expiring pid_ bearer) and a missing value are never expired.
     if (typeof expiresAt !== 'number' || expiresAt === 0)
         return false;
-    return expiresAt <= Date.now() / 1000;
+    // expires_at is Unix milliseconds — compare ms to ms.
+    return expiresAt <= Date.now();
 }

package/dist/lib/secrets/drivers/rush.js

@@ -29,7 +29,7 @@ function readRushToken() {
     }
     const expiresAt = data.session?.expires_at;
     if (isRushSessionExpired(expiresAt)) {
-        const expiredAt = new Date(expiresAt * 1000).toISOString();
+        const expiredAt = new Date(expiresAt).toISOString();
         throw new Error(`Rush session expired at ${expiredAt}. Run \`rush login\` to refresh.`);
     }
     return token;

package/dist/lib/session/active.d.ts

@@ -402,6 +402,18 @@ export interface ActiveSession {
      * did not inherit a terminal id.
      */
     terminalId?: string;
+    /**
+     * The launch id (`AGENT_LAUNCH_ID`) the CLI stamps on every agent at spawn — a
+     * stable UUID that is identical locally and across an SSH hop and survives a
+     * session-id rotation (`/clear`, exit-and-rerun). Unlike `sessionId` (which the
+     * non-Claude harnesses only mint after boot) it exists from the first tick, so
+     * it is the join key a client uses to re-identify a session on the watch stream.
+     * Populated wherever the by-pid launch registry resolves — reliably for
+     * `agents run`-launched processes; still absent for editor-launched terminals
+     * whose shell pid does not line up with the agent-pid registry today (the same
+     * limitation the `readPidSessionEntry` call in `listTerminalsActive` documents).
+     */
+    launchId?: string;
     /**
      * tmux pane id (`%N`) when this row was discovered via the tmux source AND its
      * session id could not be resolved (a born-unidentifiable non-Claude pane). It

package/dist/lib/session/active.js

@@ -1059,6 +1059,8 @@ export async function listTerminalsActive() {
             tty: procByPid.get(t.pid)?.tty,
             pid: t.pid,
             sessionId: t.sessionId ?? sessionIdFromFile(sessionFile),
+            launchId: pidEntry?.launchId,
+            terminalId: pidEntry?.terminalId,
             cwd: t.cwd ?? undefined,
             label,
             name,
@@ -1558,7 +1560,8 @@ async function listUnattributedActiveLive(attributed) {
             lastActivityMs: mtimeMs,
             pidCount: 1 + (foldedByRoot.get(pid) ?? 0),
             owner: resolveOwner(entry?.actor, resolvedId),
-            terminalId: entry?.terminalId,
+            launchId: entry?.launchId ?? hookRec?.launch_id,
+            terminalId: entry?.terminalId ?? hookRec?.terminal_id,
         }, state, sessionFile, true));
     }
     // Housekeeping: drop registry files for pids that have since died.
@@ -1773,6 +1776,7 @@ export async function listTmuxAgentSessions() {
             // Factory / --active join key: AGENT_TERMINAL_ID stamped on the launch
             // registry and preserved by SessionStart. Without this, Grok/Codex tmux
             // panes never surface terminalId even when by-pid has it (RUSH-2192).
+            launchId: liveEntry?.launchId,
             terminalId: liveEntry?.terminalId,
             // An id-less pane keys its dedupe on the unique pane, so two anonymous
             // co-located panes stay two rows instead of folding into one.

package/dist/lib/session/actor-sidecar.d.ts

@@ -5,6 +5,13 @@ export interface SessionActorRecord {
     actor?: string;
     /** Actor kind (`resolveActor().kind`). */
     initiatedBy?: 'human' | 'agent';
+    /**
+     * Phoenix id of the responsible actor (`resolveActor().phoenixId`) — the
+     * tailnet human's stable Phoenix identity, resolved from the `actors:` map at
+     * spawn (PHNX-3798). Pairs with {@link actor}: joined onto the session index at
+     * scan time so a durable listing can surface the Phoenix id, not just the email.
+     */
+    phoenixId?: string;
     /** Effective permissions mode used by the launcher. */
     mode?: SessionRunMode;
     /**

package/dist/lib/session/actor-sidecar.js

@@ -39,6 +39,7 @@ function isSafeAlias(alias) {
 }
 function hasRecordData(record) {
     return typeof record.actor === 'string'
+        || typeof record.phoenixId === 'string'
         || typeof record.mode === 'string'
         || typeof record.version === 'string'
         || typeof record.harness === 'string'
@@ -84,6 +85,7 @@ export function writeSessionAliasRecord(sessionId, alias) {
             sessionId,
             actor: previous?.actor,
             initiatedBy: previous?.initiatedBy,
+            phoenixId: previous?.phoenixId,
             mode: previous?.mode,
             version: previous?.version,
             harness: previous?.harness,

package/dist/lib/session/cloud.js

@@ -32,7 +32,7 @@ function readToken() {
     }
     const expiresAt = data.session?.expires_at;
     if (isRushSessionExpired(expiresAt)) {
-        const expiredAt = new Date(expiresAt * 1000).toISOString();
+        const expiredAt = new Date(expiresAt).toISOString();
         throw new Error(`Rush session expired at ${expiredAt}. Run \`rush login\` to refresh.`);
     }
     return token;

package/dist/lib/session/db.d.ts

@@ -13,7 +13,7 @@ import { type ToolScanResumePoint } from './tool-store.js';
 /** Current schema version; bumped when migrations are added. Exported so tests
  * assert against the constant instead of hardcoding a number that every bump
  * then has to chase (docs/sessions.md calls the constant the source of truth). */
-export declare const SCHEMA_VERSION = 45;
+export declare const SCHEMA_VERSION = 47;
 /**
  * Bump to force the content extractor (assistant-answer text, alongside the
  * user-prompt text every harness already accumulates) to re-derive on every
@@ -443,6 +443,65 @@ export declare function readSessionContent(id: string): string | undefined;
  * survives for this session.
  */
 export declare function readArchivedSessionPreview<T>(id: string): T | undefined;
+/** A local-origin session, projected to the compact fields the fleet mirror publishes. */
+export interface LocalMirrorSource {
+    id: string;
+    shortId: string;
+    agent: string;
+    version: string | null;
+    machine: string | null;
+    cwd: string | null;
+    topic: string | null;
+    firstUserMessage: string | null;
+    label: string | null;
+    lastActivity: string | null;
+    timestamp: string;
+    ticketId: string | null;
+    prUrl: string | null;
+}
+/**
+ * The most-recently-active sessions whose transcript is genuinely local to this
+ * box — a real `file_path`, not a peer mirror — for publishing to the fleet
+ * session mirror (PHNX-3792). Bounded and team-origin-excluded so the published
+ * payload stays the size a picker would show. Never returns a row this box is
+ * itself mirroring from a peer (`mirror_synced_at IS NULL`).
+ */
+export declare function queryLocalOriginSessionsForMirror(self: string, limit: number): LocalMirrorSource[];
+/** One peer session digest to write into this box's local mirror. */
+export interface MirrorSessionUpsert {
+    id: string;
+    shortId: string;
+    agent: string;
+    version?: string | null;
+    machine: string;
+    cwd?: string | null;
+    topic?: string | null;
+    firstUser?: string | null;
+    label?: string | null;
+    lastActivity?: string | null;
+    timestamp: string;
+    ticketId?: string | null;
+    prUrl?: string | null;
+}
+/**
+ * Write one peer session's digest into the local `sessions` index as a mirror
+ * row (PHNX-3792), so the picker/list/focus render its topic/preview inline
+ * with no per-row SSH. The upsert is GUARDED: it never overwrites a genuine
+ * local transcript row (`file_path` non-empty and not itself a mirror), so a
+ * mirror can only create a new peer-only row or enrich an existing empty-file
+ * host-dispatch stub / older mirror. Returns true when a row was written (the
+ * caller then persists the matching preview digest); false when a real row was
+ * protected. `machine` carries the publisher's recorded execution host so the
+ * row collapses with the live fan-out row under the same `machine:id` key.
+ */
+export declare function upsertMirrorSession(row: MirrorSessionUpsert, source: string, syncedAt: number): boolean;
+/**
+ * Drop peer mirror rows (and their cached digests) whose last sync predates the
+ * cutoff — the size ceiling / staleness pruner for the fleet session mirror
+ * (PHNX-3792). Only ever touches mirror rows (`mirror_synced_at IS NOT NULL`),
+ * never a genuine local or host-dispatch row. Returns the number of rows pruned.
+ */
+export declare function pruneMirrorSessions(cutoffMs: number): number;
 /** Plugin provenance already indexed for resources used by one session. */
 export declare function getSessionPlugins(id: string): string[];
 export type UsageRollupGroup = 'agent' | 'project' | 'day' | 'account';