@phnx-labs/agents-cli 1.22.120 → 1.22.121

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

@@ -1,39 +1,16 @@
-import { type SessionRunMode } from './types.js';
+import { type SessionRunMode } from '@phnx-labs/sessions-cli/reader';
 interface SessionActorRecord {
     sessionId: string;
-    /** Resolved actor id (`resolveActor().id`) — the responsible human/agent. */
     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;
-    /** Installed executable label at launch; provenance only, never account identity. */
     version?: string;
-    /** Credential account used at launch, independent of the installed executable. */
     accountId?: string;
-    /**
-     * Custom harness / profile name when launched via `agents run <profile>`
-     * (e.g. `deepseek`). Joined onto the session index at scan time so a
-     * durable listing can distinguish the profile from its host agent
-     * (PHNX-2935).
-     */
     harness?: string;
-    /** Stable wrapper names that resolve to this native session id. */
     aliases?: string[];
     startedAtMs: number;
 }
-/**
- * Record the actor a session was launched under. Never throws — the sidecar is
- * an attribution optimization; a session with no record simply scans unattributed.
- * No-ops without a concrete session id (nothing to key on).
- */
 export declare function writeSessionActorRecord(record: SessionActorRecord): void;
 export declare function writeSessionAliasRecord(sessionId: string, alias: string): void;
 type SessionAliasResolution = {
@@ -45,15 +22,7 @@ type SessionAliasResolution = {
 } | {
     kind: 'not-found';
 };
-/** Resolve an exact alias, or a unique prefix/suffix of at least six chars. */
 export declare function resolveSessionAlias(selector: string): SessionAliasResolution;
-/** Read one session's actor record. Returns undefined if absent/corrupt. */
 export declare function readSessionActorRecord(sessionId: string): SessionActorRecord | undefined;
-/**
- * Load every session actor record into a `sessionId -> record` map, for the scan
- * path to join a whole batch of sessions in one directory read instead of a
- * stat-per-row. Best-effort: unreadable/corrupt files are skipped, a missing dir
- * yields an empty map.
- */
 export declare function loadSessionActorIndex(): Map<string, SessionActorRecord>;
 export {};

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

@@ -1,33 +1,10 @@
-/**
- * Durable sessionId -> actor sidecar (RUSH-2019, P3 lineage).
- *
- * The actor behind a run is resolved at spawn (`resolveActor()`), but the session
- * transcript on disk carries no record of it — so the scanner that indexes those
- * transcripts into `sessions.db` (`discover.ts` -> `upsertSessionsBatch`) has
- * nothing to attribute a session to a person with. The pid-registry answers this
- * for LIVE processes (`--active` owner, RUSH-2018), but it lives under `.cache`
- * and is pruned when the pid dies, so it can't back a DURABLE, historical listing.
- *
- * This module writes one small, durable record per launched session — keyed by
- * session id, under `~/.agents/.history` (never pruned) — that the scanner joins
- * on to fill the write-once `actor` / `initiated_by` columns. Best-effort
- * throughout: a failed write or a corrupt file degrades to an unattributed row,
- * never throws into the launch or the scan path.
- */
 import fs from 'fs';
 import path from 'path';
 import { getHistoryDir } from '../state.js';
-import { isAgentTmuxAlias } from './types.js';
+import { isAgentTmuxAlias } from '@phnx-labs/sessions-cli/reader';
 function sidecarDir() {
     return path.join(getHistoryDir(), 'by-session');
 }
-/**
- * A session id safe to use as a filename: no path separators or `..`, so a
- * caller-supplied `--session-id` can never escape `by-session/` via
- * `path.join`. Session ids are uuids in practice; anything else is rejected
- * rather than sanitized, so a bad id degrades to no record, never a write
- * outside the directory.
- */
 function isSafeSessionId(sessionId) {
     return sessionId.length > 0 && !/[/\\]/.test(sessionId) && sessionId !== '.' && sessionId !== '..';
 }
@@ -57,11 +34,6 @@ function writeRecord(record) {
     fs.mkdirSync(sidecarDir(), { recursive: true });
     fs.writeFileSync(recordPath(record.sessionId), JSON.stringify(record), 'utf8');
 }
-/**
- * Record the actor a session was launched under. Never throws — the sidecar is
- * an attribution optimization; a session with no record simply scans unattributed.
- * No-ops without a concrete session id (nothing to key on).
- */
 export function writeSessionActorRecord(record) {
     if (!isSafeSessionId(record.sessionId))
         return;
@@ -75,7 +47,6 @@ export function writeSessionActorRecord(record) {
         });
     }
     catch {
-        /* degrade to an unattributed row */
     }
 }
 export function writeSessionAliasRecord(sessionId, alias) {
@@ -97,10 +68,8 @@ export function writeSessionAliasRecord(sessionId, alias) {
         });
     }
     catch {
-        /* the native id remains usable */
     }
 }
-/** Resolve an exact alias, or a unique prefix/suffix of at least six chars. */
 export function resolveSessionAlias(selector) {
     const normalized = selector.trim().toLowerCase();
     if (!normalized)
@@ -122,7 +91,6 @@ export function resolveSessionAlias(selector) {
         return { kind: 'ambiguous', sessionIds: matches.sort() };
     return { kind: 'resolved', sessionId: matches[0] };
 }
-/** Read one session's actor record. Returns undefined if absent/corrupt. */
 export function readSessionActorRecord(sessionId) {
     if (!isSafeSessionId(sessionId))
         return undefined;
@@ -141,16 +109,9 @@ export function readSessionActorRecord(sessionId) {
         }
     }
     catch {
-        /* unparseable */
     }
     return undefined;
 }
-/**
- * Load every session actor record into a `sessionId -> record` map, for the scan
- * path to join a whole batch of sessions in one directory read instead of a
- * stat-per-row. Best-effort: unreadable/corrupt files are skipped, a missing dir
- * yields an empty map.
- */
 export function loadSessionActorIndex() {
     const out = new Map();
     let files;
@@ -169,7 +130,6 @@ export function loadSessionActorIndex() {
             }
         }
         catch {
-            /* raced with a writer, or corrupt — skip */
         }
     }
     return out;

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

@@ -1,39 +1,6 @@
-/**
- * Bookmarked sessions — the durable "keep this one handy" mark a human puts on a
- * session, deliberately kept OUT of the session index.
- *
- * `sessions.db` is a rebuildable CACHE: a reindex or a schema bump throws its
- * rows away and re-derives them from the transcripts on disk. A bookmark is not
- * derivable from a transcript — it is a human's choice — so a column there would
- * be silently lost on the next rebuild. It lives in `~/.agents/.history/` instead,
- * next to the actor sidecars, which is never pruned.
- *
- * One flat set of session ids. The id is the transcript's own uuid, so it is
- * stable and machine-independent — but the file is NOT synced today: session sync
- * carries `.history/backups/` (`lib/session/sync/agents.ts`), not this. Bookmarks
- * are therefore per-machine; carrying them across the fleet would mean adding
- * them to the sync manifest, which this does not do.
- *
- * Reads are memoized against the file's mtime — the picker asks `isBookmarked` once
- * per rendered row, and re-reading a JSON file per row on every keystroke is the
- * kind of cost that makes a TUI feel broken.
- */
 export declare function bookmarksFilePath(): string;
-/** Drop the memoized read. Tests that write the file directly need this; nothing
- *  in the CLI does, because every mutation here refreshes the cache itself. */
 export declare function clearBookmarksCache(): void;
-/**
- * Every bookmarked session id. Empty (never throws) when the file is absent,
- * unreadable, or malformed — a corrupt bookmarks file must not take down
- * `agents sessions`.
- */
 export declare function listBookmarks(): Set<string>;
 export declare function isBookmarked(sessionId: string | undefined): boolean;
-/**
- * Set (or clear) the bookmark mark on a session. Returns the resulting state, so
- * a caller can report it without a second read. A no-op write is skipped, which
- * keeps the file's mtime — and every other process's memoized read — untouched.
- */
 export declare function setBookmark(sessionId: string, on: boolean): boolean;
-/** Flip the mark; returns the new state (`true` = now bookmarked). */
 export declare function toggleBookmark(sessionId: string): boolean;

package/dist/lib/session/bookmarks.js

@@ -1,31 +1,9 @@
-/**
- * Bookmarked sessions — the durable "keep this one handy" mark a human puts on a
- * session, deliberately kept OUT of the session index.
- *
- * `sessions.db` is a rebuildable CACHE: a reindex or a schema bump throws its
- * rows away and re-derives them from the transcripts on disk. A bookmark is not
- * derivable from a transcript — it is a human's choice — so a column there would
- * be silently lost on the next rebuild. It lives in `~/.agents/.history/` instead,
- * next to the actor sidecars, which is never pruned.
- *
- * One flat set of session ids. The id is the transcript's own uuid, so it is
- * stable and machine-independent — but the file is NOT synced today: session sync
- * carries `.history/backups/` (`lib/session/sync/agents.ts`), not this. Bookmarks
- * are therefore per-machine; carrying them across the fleet would mean adding
- * them to the sync manifest, which this does not do.
- *
- * Reads are memoized against the file's mtime — the picker asks `isBookmarked` once
- * per rendered row, and re-reading a JSON file per row on every keystroke is the
- * kind of cost that makes a TUI feel broken.
- */
 import fs from 'node:fs';
 import path from 'node:path';
 import { getHistoryDir } from '../state.js';
 export function bookmarksFilePath() {
     return path.join(getHistoryDir(), 'bookmarks.json');
 }
-/** Memoized parse, invalidated by the file's mtime+size (another process — or
- *  another machine's sync — can rewrite it under us). */
 let cache = null;
 function statKey(file) {
     try {
@@ -36,16 +14,9 @@ function statKey(file) {
         return 'absent';
     }
 }
-/** Drop the memoized read. Tests that write the file directly need this; nothing
- *  in the CLI does, because every mutation here refreshes the cache itself. */
 export function clearBookmarksCache() {
     cache = null;
 }
-/**
- * Every bookmarked session id. Empty (never throws) when the file is absent,
- * unreadable, or malformed — a corrupt bookmarks file must not take down
- * `agents sessions`.
- */
 export function listBookmarks() {
     const file = bookmarksFilePath();
     const key = statKey(file);
@@ -59,7 +30,6 @@ export function listBookmarks() {
         }
     }
     catch {
-        // absent / unreadable / malformed — an empty set is the honest answer
     }
     cache = { key, ids };
     return ids;
@@ -69,7 +39,6 @@ export function isBookmarked(sessionId) {
         return false;
     return listBookmarks().has(sessionId);
 }
-/** Atomic write (tmp + rename) so a concurrent reader never sees a half file. */
 function writeBookmarks(ids) {
     const file = bookmarksFilePath();
     fs.mkdirSync(path.dirname(file), { recursive: true });
@@ -79,11 +48,6 @@ function writeBookmarks(ids) {
     fs.renameSync(tmp, file);
     cache = { key: statKey(file), ids };
 }
-/**
- * Set (or clear) the bookmark mark on a session. Returns the resulting state, so
- * a caller can report it without a second read. A no-op write is skipped, which
- * keeps the file's mtime — and every other process's memoized read — untouched.
- */
 export function setBookmark(sessionId, on) {
     const ids = new Set(listBookmarks());
     if (ids.has(sessionId) === on)
@@ -95,7 +59,6 @@ export function setBookmark(sessionId, on) {
     writeBookmarks(ids);
     return on;
 }
-/** Flip the mark; returns the new state (`true` = now bookmarked). */
 export function toggleBookmark(sessionId) {
     return setBookmark(sessionId, !isBookmarked(sessionId));
 }

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

@@ -1,69 +1,32 @@
-/**
- * Portable session bundle — the on-the-wire format behind `agents sessions
- * export` / `import` (RUSH-1710 / RUSH-1711).
- *
- * A bundle is a self-describing NDJSON stream: the FIRST line is a
- * {@link BundleHeader}, every subsequent line is one {@link BundleRecord} (one
- * constituent file of a session). NDJSON — not tar — because the bundle has to
- * pipe cleanly over `agents ssh … export --stdout | … import -` (RUSH-1712)
- * without any external archiver on either box, stays inspectable with `head`,
- * and lets each file body carry its own encryption envelope.
- *
- * This module owns the FORMAT and the import PLACEMENT only; selecting which
- * sessions to export (which needs the session DB) lives in the export command.
- * Placement reuses the sync mirror model verbatim: a foreign machine's session
- * lands at {@link mirrorPath}(spec, originMachine, relKey), exactly where the
- * cross-machine sync writes it — so the existing scanner indexes it as a
- * machine-tagged row and "local always wins" falls out of the scanner's
- * live-home-first dedup with no extra logic here.
- */
 import { type SyncAgentSpec } from './sync/agents.js';
 export declare const BUNDLE_KIND = "agents-session-bundle";
-/** First line of a bundle: what it is and how the bodies are encoded. */
 export interface BundleHeader {
     kind: typeof BUNDLE_KIND;
     version: number;
-    /** ISO timestamp the bundle was produced. */
     exportedAt: string;
-    /** Machine that produced the bundle (informational; per-record `machine` is authoritative for placement). */
     origin: string;
-    /** True when record bodies are AES-256-GCM envelopes (see transcript-crypto). */
     encrypted: boolean;
-    /** True when bodies were secret-scrubbed before hashing/sealing. */
     redacted: boolean;
-    /** Number of file records that follow. */
     count: number;
-    /** Distinct session count across those records. */
     sessions: number;
 }
-/** One constituent file of one session. Dir-shaped sessions emit several, sharing `sessionId`. */
 export interface BundleRecord {
-    /** SYNC_AGENTS id (claude, codex, kimi, …). */
     agent: string;
-    /** ORIGIN machine of this session — where placement mirrors it to. */
     machine: string;
     sessionId: string;
-    /** Storage-relative key within the agent's subdir (preserved on import). */
     relKey: string;
-    /** Byte length of the plaintext body. */
     size: number;
-    /** SHA-256 of the plaintext body — identity + byte-exact dedup. */
     hash: string;
-    /** Human label carried from SessionMeta, if any. */
     label?: string;
-    /** True when `body` is an encryption envelope rather than plaintext. */
     encrypted: boolean;
-    /** File content: plaintext, or a transcript-crypto envelope when `encrypted`. */
     body: string;
 }
 export interface ParsedBundle {
     header: BundleHeader;
     records: BundleRecord[];
 }
-/** A single file selected for export, resolved to an absolute on-disk path. */
 export interface FileToExport {
     agent: string;
-    /** Origin machine of the session (self for live-home, the peer for a mirror). */
     machine: string;
     sessionId: string;
     relKey: string;
@@ -71,27 +34,12 @@ export interface FileToExport {
     label?: string;
 }
 interface BuildRecordOpts {
-    /** Scrub secrets from the body before hashing/sealing (default-on at the command layer). */
     redact: boolean;
-    /** Non-null → seal each body with this key; null → plaintext bodies. */
     encryptKey: Buffer | null;
-    /**
-     * Literal secret values to mask verbatim during redaction (value-aware pass):
-     * e.g. live credentials from an injected secrets bundle, so they never leak in
-     * an exported transcript regardless of format. Only used when `redact` is set.
-     */
     knownSecrets?: readonly string[];
 }
-/** Look up the sync spec for an agent id (undefined → agent not sync-representable). */
 export declare function specForAgent(agentId: string): SyncAgentSpec | undefined;
-/**
- * Read one file and turn it into a bundle record. The hash and size are always
- * computed over the PLAINTEXT (post-redaction) body, so they equal what lands on
- * disk after import — keeping dedup byte-exact whether or not the bundle is
- * encrypted.
- */
 export declare function buildRecord(file: FileToExport, opts: BuildRecordOpts): BundleRecord;
-/** Build the header for a set of records. */
 export declare function makeHeader(args: {
     origin: string;
     exportedAt: string;
@@ -99,64 +47,30 @@ export declare function makeHeader(args: {
     redacted: boolean;
     records: BundleRecord[];
 }): BundleHeader;
-/**
- * Merge record sets from several bundles (e.g. a fan-out pull across hosts),
- * deduping by agent + origin machine + session + file so the same session seen
- * from two peers lands once. First occurrence wins.
- */
 export declare function mergeRecords(sets: BundleRecord[][]): BundleRecord[];
-/** Serialize a bundle to its NDJSON wire form (header line + one line per record). */
 export declare function serializeBundle(header: BundleHeader, records: BundleRecord[]): string;
-/**
- * Write a serialized bundle to disk owner-only (0600). A bundle carries raw
- * transcript bodies — even redacted, never world/group-readable — and encryption
- * is opt-in, so the file mode is the baseline confidentiality guard. `mode` on
- * `writeFileSync` only applies when the file is created, so we `chmod` too to
- * clamp an existing (possibly looser) file on overwrite.
- */
 export declare function writeBundleFile(outPath: string, wire: string): void;
-/** Parse an NDJSON bundle, validating the header kind + version. Throws on malformed input. */
 export declare function parseBundle(text: string): ParsedBundle;
-/** Placement outcome for one record, computed against what is already on disk. */
 export type ImportStatus = 'new' | 'dup' | 'conflict' | 'unknown';
 export interface ImportPlanItem {
     record: BundleRecord;
-    /** Absolute path the file lands at (empty for `unknown` agents). */
     targetPath: string;
     status: ImportStatus;
 }
 interface PlanImportOpts {
-    /** Key to open encrypted record bodies (null → only plaintext bodies readable). */
     decryptKey: Buffer | null;
 }
-/**
- * Compute where each record lands and whether it duplicates / conflicts with an
- * existing file. Pure w.r.t. the filesystem it reads (no writes). Dedup is
- * byte-exact: a target that already holds an identical body is `dup`; a target
- * that holds a DIFFERENT body is `conflict` (only overwritten with --overwrite).
- * An agent with no sync spec is `unknown` and never placed.
- */
 export declare function planImport(bundle: ParsedBundle, opts: PlanImportOpts): ImportPlanItem[];
 export interface WriteResult {
-    /** New files written. */
     placed: number;
-    /** Byte-exact dups skipped. */
     skipped: number;
-    /** Conflicts replaced (only with overwrite). */
     overwritten: number;
-    /** Conflicts left in place (overwrite off). */
     conflicts: number;
-    /** Records for agents with no sync spec. */
     unknown: number;
 }
 interface WriteImportOpts {
     overwrite: boolean;
     decryptKey: Buffer | null;
 }
-/**
- * Materialize a plan to disk. `dup` records are always skipped (local wins);
- * `conflict` records are replaced only when `overwrite` is set; `unknown` records
- * are counted and skipped.
- */
 export declare function writeImport(plan: ImportPlanItem[], opts: WriteImportOpts): WriteResult;
 export {};

package/dist/lib/session/bundle.js

@@ -1,22 +1,3 @@
-/**
- * Portable session bundle — the on-the-wire format behind `agents sessions
- * export` / `import` (RUSH-1710 / RUSH-1711).
- *
- * A bundle is a self-describing NDJSON stream: the FIRST line is a
- * {@link BundleHeader}, every subsequent line is one {@link BundleRecord} (one
- * constituent file of a session). NDJSON — not tar — because the bundle has to
- * pipe cleanly over `agents ssh … export --stdout | … import -` (RUSH-1712)
- * without any external archiver on either box, stays inspectable with `head`,
- * and lets each file body carry its own encryption envelope.
- *
- * This module owns the FORMAT and the import PLACEMENT only; selecting which
- * sessions to export (which needs the session DB) lives in the export command.
- * Placement reuses the sync mirror model verbatim: a foreign machine's session
- * lands at {@link mirrorPath}(spec, originMachine, relKey), exactly where the
- * cross-machine sync writes it — so the existing scanner indexes it as a
- * machine-tagged row and "local always wins" falls out of the scanner's
- * live-home-first dedup with no extra logic here.
- */
 import * as fs from 'fs';
 import * as path from 'path';
 import * as crypto from 'crypto';
@@ -25,20 +6,12 @@ import { redactSecrets } from '../redact.js';
 import { encryptTranscript, decryptTranscriptBody } from './sync/transcript-crypto.js';
 export const BUNDLE_KIND = 'agents-session-bundle';
 const BUNDLE_VERSION = 1;
-/** SHA-256 of a file body, used for the bundle's dedup/conflict check on import. */
 function hashContent(content) {
     return crypto.createHash('sha256').update(content).digest('hex');
 }
-/** Look up the sync spec for an agent id (undefined → agent not sync-representable). */
 export function specForAgent(agentId) {
     return SYNC_AGENTS.find(s => s.id === agentId);
 }
-/**
- * Read one file and turn it into a bundle record. The hash and size are always
- * computed over the PLAINTEXT (post-redaction) body, so they equal what lands on
- * disk after import — keeping dedup byte-exact whether or not the bundle is
- * encrypted.
- */
 export function buildRecord(file, opts) {
     let body = fs.readFileSync(file.absPath, 'utf-8');
     if (opts.redact)
@@ -65,7 +38,6 @@ export function buildRecord(file, opts) {
         rec.label = file.label;
     return rec;
 }
-/** Build the header for a set of records. */
 export function makeHeader(args) {
     const sessions = new Set(args.records.map(r => `${r.agent}:${r.machine}:${r.sessionId}`)).size;
     return {
@@ -79,11 +51,6 @@ export function makeHeader(args) {
         sessions,
     };
 }
-/**
- * Merge record sets from several bundles (e.g. a fan-out pull across hosts),
- * deduping by agent + origin machine + session + file so the same session seen
- * from two peers lands once. First occurrence wins.
- */
 export function mergeRecords(sets) {
     const seen = new Set();
     const out = [];
@@ -98,25 +65,16 @@ export function mergeRecords(sets) {
     }
     return out;
 }
-/** Serialize a bundle to its NDJSON wire form (header line + one line per record). */
 export function serializeBundle(header, records) {
     const lines = [JSON.stringify(header)];
     for (const r of records)
         lines.push(JSON.stringify(r));
     return lines.join('\n') + '\n';
 }
-/**
- * Write a serialized bundle to disk owner-only (0600). A bundle carries raw
- * transcript bodies — even redacted, never world/group-readable — and encryption
- * is opt-in, so the file mode is the baseline confidentiality guard. `mode` on
- * `writeFileSync` only applies when the file is created, so we `chmod` too to
- * clamp an existing (possibly looser) file on overwrite.
- */
 export function writeBundleFile(outPath, wire) {
     fs.writeFileSync(outPath, wire, { encoding: 'utf-8', mode: 0o600 });
     fs.chmodSync(outPath, 0o600);
 }
-/** Parse an NDJSON bundle, validating the header kind + version. Throws on malformed input. */
 export function parseBundle(text) {
     const lines = text.split('\n').filter(l => l.trim().length > 0);
     if (lines.length === 0)
@@ -145,13 +103,6 @@ export function parseBundle(text) {
     }
     return { header, records };
 }
-/**
- * Compute where each record lands and whether it duplicates / conflicts with an
- * existing file. Pure w.r.t. the filesystem it reads (no writes). Dedup is
- * byte-exact: a target that already holds an identical body is `dup`; a target
- * that holds a DIFFERENT body is `conflict` (only overwritten with --overwrite).
- * An agent with no sync spec is `unknown` and never placed.
- */
 export function planImport(bundle, opts) {
     return bundle.records.map((record) => {
         const spec = specForAgent(record.agent);
@@ -168,11 +119,6 @@ export function planImport(bundle, opts) {
         return { record, targetPath, status };
     });
 }
-/**
- * Materialize a plan to disk. `dup` records are always skipped (local wins);
- * `conflict` records are replaced only when `overwrite` is set; `unknown` records
- * are counted and skipped.
- */
 export function writeImport(plan, opts) {
     const res = { placed: 0, skipped: 0, overwritten: 0, conflicts: 0, unknown: 0 };
     for (const item of plan) {

package/dist/lib/session/claude-accounts.d.ts

@@ -1,67 +1,27 @@
-/** The account a transcript is attributed to. */
 export interface ClaudeAccountBucket {
-    /**
-     * Stable grouping key. For an attributed bucket this is the org-scoped `usageKey`
-     * (e.g. `claude:org=<uuid>`). For an unattributed one it is `unattributed:<reason>`
-     * so distinct dark sources never merge into each other or into a real account.
-     */
     key: string;
-    /** True when the key came from a real `oauthAccount`. */
     attributed: boolean;
     email: string | null;
     orgName: string | null;
-    /** "Team", "Max", "Pro", … derived from `organizationType`. */
     plan: string | null;
-    /** Display string: org and email, or the reason a bucket is dark. */
     label: string;
-    /** Which evidence tier produced this attribution. */
     evidence: 'version-home' | 'recorded-version' | 'symlink-target' | 'none';
 }
 interface HomeEntry {
-    /** Literal path prefix a transcript must start with to belong to this home. */
     prefix: string;
     bucket: ClaudeAccountBucket;
 }
-/** Resolver over the Claude homes present on this machine. */
 export interface ClaudeAccountIndex {
-    /** Version-, account-slot-, and trash-home prefixes, longest first. Excludes the `~/.claude` symlink. */
     entries: HomeEntry[];
-    /**
-     * Config-dir prefixes of homes that exist but carry no `oauthAccount`. Kept
-     * separately from `entries` so a transcript living in a signed-out home is reported
-     * against THAT home rather than falling through to its recorded version: the file's
-     * location is what proves which config dir Claude was pointed at.
-     */
     darkHomes: Array<{
         prefix: string;
         version: string | null;
     }>;
-    /**
-     * Claude CLI version → the account that version ran as. `'ambiguous'` when retired
-     * snapshots of one version disagree and no live home settles it, which is reported
-     * as dark rather than guessed.
-     */
     byVersion: Map<string, ClaudeAccountBucket | 'ambiguous'>;
-    /**
-     * Account-slot id (`<historyDir>/accounts/claude/<accountId>/`, PHNX-3940) →
-     * the identity read from that slot's own `.claude.json`. A slot's identity is
-     * proven the same way a version home's is — tier 1 evidence, see
-     * {@link resolveClaudeAccount} — so this map exists only to let a launch-
-     * recorded accountId (once the actor sidecar carries one) resolve straight to
-     * a bucket without re-deriving it from a path.
-     */
     byAccountId: Map<string, ClaudeAccountBucket>;
-    /** Whatever `~/.claude` points at right now; tier-3 evidence only. */
     symlinkBucket: ClaudeAccountBucket | null;
-    /** Literal prefix of the live symlinked config dir. */
     symlinkPrefix: string;
 }
-/**
- * Enumerate every Claude home that could own an indexed transcript. Includes retired
- * `trash/` snapshots: they keep their `.claude.json`, so a transcript indexed before
- * its version was rotated out stays attributable.
- */
 export declare function buildClaudeAccountIndex(): ClaudeAccountIndex;
-/** Resolve a quota bucket without replacing recorded login provenance. */
 export declare function resolveClaudeAccount(index: ClaudeAccountIndex, filePath: string, recordedVersion?: string | null, launchAccountId?: string | null): ClaudeAccountBucket;
 export {};