byterover-cli 3.11.0 → 3.13.0

package/dist/server/core/domain/transport/schemas.js

@@ -9,6 +9,7 @@
  */
 import { z } from 'zod';
 import { QUERY_LOG_TIERS } from '../../domain/entities/query-log-entry.js';
+import { TaskHistoryEntrySchema } from '../entities/task-history-entry.js';
 // ============================================================================
 // Zod Schemas for Runtime Validation (mirrors domain types)
 // ============================================================================
@@ -211,12 +212,22 @@ export const TransportTaskEventNames = {
     CANCEL: 'task:cancel',
     // Task terminal states
     CANCELLED: 'task:cancelled',
+    // Bulk delete terminal entries (M2.09)
+    CLEAR_COMPLETED: 'task:clearCompleted',
     COMPLETED: 'task:completed',
     CREATE: 'task:create',
     CREATED: 'task:created',
+    // Single delete (M2.09)
+    DELETE: 'task:delete',
+    // Multi delete (M2.09)
+    DELETE_BULK: 'task:deleteBulk',
+    // Broadcast on successful removal (M2.09)
+    DELETED: 'task:deleted',
     ERROR: 'task:error',
     // Internal (Transport → Agent)
     EXECUTE: 'task:execute',
+    // Single-task detail fetch (M2.09)
+    GET: 'task:get',
     // Snapshot query (Client → Transport)
     LIST: 'task:list',
     // Query metadata (Agent → Daemon, before task:completed)
@@ -267,6 +278,8 @@ export const TransportAgentEventNames = {
  */
 export const TransportStateEventNames = {
     GET_AUTH: 'state:getAuth',
+    GET_BILLING_CONFIG: 'state:getBillingConfig',
+    GET_PAID_ORGANIZATIONS: 'state:getPaidOrganizations',
     GET_PROJECT_CONFIG: 'state:getProjectConfig',
     GET_PROVIDER_CONFIG: 'state:getProviderConfig',
 };
@@ -275,6 +288,7 @@ export const TransportStateEventNames = {
  * Used to notify agent child processes of global state changes.
  */
 export const TransportDaemonEventNames = {
+    BILLING_PIN_CHANGED: 'billing:pinChanged',
     PROVIDER_UPDATED: 'provider:updated',
 };
 /**
@@ -386,6 +400,10 @@ export const TaskCreatedSchema = z.object({
     files: z.array(z.string()).optional(),
     /** Folder path for curate-folder task type */
     folderPath: z.string().optional(),
+    /** Active model id at task creation time */
+    model: z.string().optional(),
+    /** Active provider id at task creation time */
+    provider: z.string().optional(),
     /** Unique task identifier */
     taskId: z.string(),
     /** Task type */
@@ -443,7 +461,9 @@ export const TaskQueryResultEventSchema = z.object({
     })
         .optional(),
     taskId: z.string(),
-    tier: z.custom((val) => new Set(QUERY_LOG_TIERS).has(val), { message: 'Invalid query log tier' }),
+    tier: z.custom((val) => new Set(QUERY_LOG_TIERS).has(val), {
+        message: 'Invalid query log tier',
+    }),
     timing: z.object({ durationMs: z.number() }),
 });
 /**
@@ -563,11 +583,38 @@ export const TaskCancelResponseSchema = z.object({
 /**
  * task:list - Snapshot of active and recently-completed tasks for a project.
  * Used by the web UI Tasks tab to populate state without replaying history.
- */
-export const TaskListRequestSchema = z.object({
-    /** Optional project filter — defaults to caller's registered project */
+ *
+ * M2.16: cursor pagination dropped; numbered pagination (page/pageSize) +
+ * full filter dimensions (search/provider/model/time/duration).
+ */
+export const TaskListRequestSchema = z
+    .object({
+    /** Created at >= this epoch ms (M2.16). */
+    createdAfter: z.number().optional(),
+    /** Created at <= this epoch ms (M2.16). */
+    createdBefore: z.number().optional(),
+    /** Maximum elapsed time (ms) for terminal tasks (M2.16). */
+    maxDurationMs: z.number().optional(),
+    /** Minimum elapsed time (ms) for terminal tasks; only matches startedAt+completedAt rows (M2.16). */
+    minDurationMs: z.number().optional(),
+    /** Optional model id filter (M2.16). */
+    model: z.array(z.string()).optional(),
+    /** 1-based page index — server clamps to >= 1; defaults to 1 (M2.16). */
+    page: z.number().int().min(1).optional(),
+    /** Page size — server clamps to 1..1000; defaults to 50 (M2.16). */
+    pageSize: z.number().int().min(1).max(1000).optional(),
+    /** Optional project filter — defaults to caller's registered project. */
     projectPath: z.string().optional(),
-});
+    /** Optional provider id filter (M2.16). */
+    provider: z.array(z.string()).optional(),
+    /** Case-insensitive substring search over content + result + error.message (M2.16). */
+    searchText: z.string().optional(),
+    /** Optional status filter — return only tasks whose status matches one of these. */
+    status: z.array(z.enum(['cancelled', 'completed', 'created', 'error', 'started'])).optional(),
+    /** Optional task-type filter — e.g. ['curate'], ['query']. */
+    type: z.array(z.string()).optional(),
+})
+    .strict();
 export const TaskListItemStatusSchema = z.enum(['cancelled', 'completed', 'created', 'error', 'started']);
 export const TaskListItemSchema = z.object({
     completedAt: z.number().optional(),
@@ -578,15 +625,122 @@ export const TaskListItemSchema = z.object({
     files: z.array(z.string()).optional(),
     /** Folder path for `curate-folder` tasks */
     folderPath: z.string().optional(),
+    /** Active model id at task creation time */
+    model: z.string().optional(),
     projectPath: z.string().optional(),
+    /** Active provider id at task creation time */
+    provider: z.string().optional(),
+    /**
+     * Result string. Only present for in-memory completed tasks (toListItem
+     * populates from TaskInfo.result). Persisted entries from the index do not
+     * carry result by 2-tier design — detail panel uses task:get for full text.
+     */
     result: z.string().optional(),
     startedAt: z.number().optional(),
     status: TaskListItemStatusSchema,
     taskId: z.string(),
     type: z.string(),
 });
-export const TaskListResponseSchema = z.object({
+/** Status histogram used by FE filter-bar breakdown (M2.16). */
+export const TaskListCountsSchema = z.object({
+    all: z.number().int().nonnegative(),
+    cancelled: z.number().int().nonnegative(),
+    completed: z.number().int().nonnegative(),
+    /** Tasks with status === 'error'. */
+    failed: z.number().int().nonnegative(),
+    /** Tasks with status === 'created' || 'started'. */
+    running: z.number().int().nonnegative(),
+});
+/** (providerId, modelId) pair from history (M2.16). */
+export const TaskListAvailableModelSchema = z.object({
+    modelId: z.string(),
+    providerId: z.string(),
+});
+export const TaskListResponseSchema = z
+    .object({
+    /** Distinct (providerId, modelId) pairs in candidate set. History-derived. */
+    availableModels: z.array(TaskListAvailableModelSchema),
+    /** Distinct providerId values in candidate set. History-derived (includes uninstalled). */
+    availableProviders: z.array(z.string()),
+    /**
+     * Status histogram matching current filter scope (Model A — post-filter,
+     * `counts.all === total` invariant). FE filter-bar chip count = visible
+     * row count.
+     */
+    counts: TaskListCountsSchema,
+    /**
+     * 1-based page index, echoed back as-sent. Server clamps lower bound only
+     * (page < 1 → 1). NOT clamped against `pageCount`: a request for `page=9999`
+     * against a 1-page result returns `{page: 9999, tasks: []}` so the caller
+     * can detect an out-of-range page and correct itself.
+     */
+    page: z.number().int().min(1),
+    /** Total page count = max(ceil(total/pageSize), 1). */
+    pageCount: z.number().int().min(1),
+    /** Page size echoed back, clamped to [1, 1000]. */
+    pageSize: z.number().int().min(1).max(1000),
+    /** Page slice of items after all filters. */
     tasks: z.array(TaskListItemSchema),
+    /** Total count of items matching ALL filters (incl. status). */
+    total: z.number().int().nonnegative(),
+})
+    .strict();
+/**
+ * task:get — fetch full Level 2 detail for a single persisted task.
+ * Returns null when the task is unknown or its data file is corrupt.
+ */
+export const TaskGetRequestSchema = z.object({
+    taskId: z.string(),
+});
+export const TaskGetResponseSchema = z.object({
+    task: TaskHistoryEntrySchema.nullable(),
+});
+/**
+ * task:delete — remove a single task from the per-project history store.
+ * Idempotent: deleting a non-existent task returns success: true.
+ */
+export const TaskDeleteRequestSchema = z.object({
+    taskId: z.string(),
+});
+export const TaskDeleteResponseSchema = z.object({
+    error: z.string().optional(),
+    /**
+     * `true` when the task was actually removed (was live in-memory or persisted),
+     * `false` when the call was a no-op (taskId unknown or already tombstoned).
+     * Idempotent semantics on `success` are preserved — `success: true` indicates
+     * the request was valid; `removed` distinguishes "actually removed" from
+     * "no-op". `task:deleteBulk` uses this to compute an accurate `deletedCount`.
+     */
+    removed: z.boolean().optional(),
+    success: z.boolean(),
+});
+/**
+ * task:deleteBulk — delete many tasks at once. `deletedCount` reports actual removals.
+ */
+export const TaskDeleteBulkRequestSchema = z.object({
+    taskIds: z.array(z.string()),
+});
+export const TaskDeleteBulkResponseSchema = z.object({
+    deletedCount: z.number(),
+    error: z.string().optional(),
+});
+/**
+ * task:clearCompleted — remove all terminal-state tasks (completed/error/cancelled)
+ * from the project's history. Active tasks (created/started) are preserved.
+ */
+export const TaskClearCompletedRequestSchema = z.object({
+    projectPath: z.string().optional(),
+});
+export const TaskClearCompletedResponseSchema = z.object({
+    deletedCount: z.number(),
+    error: z.string().optional(),
+});
+/**
+ * task:deleted — broadcast to project room when a task is removed from history.
+ * Lets other clients (TUI, other webui tabs) drop the row from their local view.
+ */
+export const TaskDeletedEventSchema = z.object({
+    taskId: z.string(),
 });
 // ============================================================================
 // Session Schemas (client → server commands)

package/dist/server/core/domain/transport/task-info.d.ts

@@ -1,7 +1,13 @@
+import type { ReasoningContentItem, ToolCallEvent } from '../../../../shared/transport/events/task-events.js';
 import type { TaskErrorData, TaskListItemStatus, TaskType } from './schemas.js';
 /**
  * Tracked task metadata used by TaskRouter for routing events
  * and by ConnectionCoordinator for agent disconnect cleanup.
+ *
+ * Level 2 fields (`responseContent`, `reasoningContents`, `toolCalls`,
+ * `sessionId`) are accumulated from `llmservice:*` events and persisted
+ * by `TaskHistoryHook` so a tab refresh mid-stream can render the in-flight
+ * state.
  */
 export type TaskInfo = {
     /** Client's working directory for file validation */
@@ -18,8 +24,16 @@ export type TaskInfo = {
     folderPath?: string;
     /** Log entry ID set by lifecycle hook after onTaskCreate */
     logId?: string;
+    /** Active model id at task creation time */
+    model?: string;
     /** Project path this task belongs to (for multi-project routing) */
     projectPath?: string;
+    /** Active provider id at task creation time */
+    provider?: string;
+    /** Accumulated reasoning/thinking entries from `llmservice:thinking` + `llmservice:chunk` (type=reasoning). */
+    reasoningContents?: ReasoningContentItem[];
+    /** Final assistant response set by `llmservice:response` (overwrites on multi-step). */
+    responseContent?: string;
     /** Set on successful completion */
     result?: string;
     /**
@@ -29,11 +43,15 @@ export type TaskInfo = {
      * the user toggles the flag mid-task.
      */
     reviewDisabled?: boolean;
+    /** LLM session id set alongside `responseContent` */
+    sessionId?: string;
     /** Set when agent picks up the task */
     startedAt?: number;
     /** Lifecycle status — defaults to 'created' on construction */
     status?: TaskListItemStatus;
     taskId: string;
+    /** Accumulated tool-call lifecycle entries from `llmservice:toolCall` + `:toolResult`. */
+    toolCalls?: ToolCallEvent[];
     type: TaskType;
     /** Workspace root (linked subdir or projectRoot if unlinked) */
     worktreeRoot?: string;

package/dist/server/core/interfaces/process/i-task-lifecycle-hook.d.ts

@@ -28,6 +28,13 @@ export interface ITaskLifecycleHook {
     }>;
     /** Called when a task fails with an error. */
     onTaskError?(taskId: string, errorMessage: string, task: TaskInfo): Promise<void>;
+    /**
+     * Called by the throttled flush (~100ms window) for in-flight task mutations
+     * — `task:started` transition + every `llmservice:*` accumulator update.
+     * Optional: existing handlers (CurateLogHandler, QueryLogHandler) don't
+     * implement it. Implementations must never throw.
+     */
+    onTaskUpdate?(task: TaskInfo): Promise<void>;
     /** Called when an LLM tool result event is received for an ACTIVE task (not grace-period). */
     onToolResult?(taskId: string, payload: LlmToolResultEvent): void;
 }

package/dist/server/core/interfaces/services/i-billing-service.d.ts

@@ -0,0 +1,26 @@
+import type { BillingFreeUserLimitDTO, BillingOrganizationTierDTO, BillingUsageDTO } from '../../../../shared/transport/types/dto.js';
+/**
+ * Reads compute-unit usage from the ByteRover billing service.
+ * Implementations may be HTTP-based (production) or stubbed (tests).
+ */
+export interface IBillingService {
+    /**
+     * Returns the user's free-tier daily/monthly limits.
+     *
+     * @param sessionKey Authenticated session token (passed via x-byterover-session-id).
+     */
+    getFreeUserLimit: (sessionKey: string) => Promise<BillingFreeUserLimitDTO>;
+    /**
+     * Returns the tier (FREE/PRO/ENTERPRISE) for every org the user belongs to.
+     *
+     * @param sessionKey Authenticated session token (passed via x-byterover-session-id).
+     */
+    getTiers: (sessionKey: string) => Promise<BillingOrganizationTierDTO[]>;
+    /**
+     * Fetches usage for every organization the authenticated user belongs to in
+     * a single round trip. Replaces the old per-org `getUsageByProjects` fan-out.
+     *
+     * @param sessionKey Authenticated session token (passed via x-byterover-session-id).
+     */
+    getUsages: (sessionKey: string) => Promise<BillingUsageDTO[]>;
+}

package/dist/server/core/interfaces/services/i-billing-service.js

@@ -0,0 +1 @@
+export {};

package/dist/server/core/interfaces/storage/i-billing-config-store.d.ts

@@ -0,0 +1,4 @@
+export interface IBillingConfigStore {
+    getPinnedTeamId: () => Promise<string | undefined>;
+    setPinnedTeamId: (teamId: string | undefined) => Promise<void>;
+}

package/dist/server/core/interfaces/storage/i-billing-config-store.js

@@ -0,0 +1 @@
+export {};

package/dist/server/core/interfaces/storage/i-task-history-store.d.ts

@@ -0,0 +1,62 @@
+import type { TaskListItem } from '../../../../shared/transport/events/task-events.js';
+import type { TaskHistoryEntry, TaskHistoryStatus } from '../../domain/entities/task-history-entry.js';
+export type { TaskHistoryEntry, TaskHistoryStatus } from '../../domain/entities/task-history-entry.js';
+export interface ITaskHistoryStore {
+    /**
+     * Tombstone all matching entries. Defaults to terminal statuses
+     * (`'cancelled' | 'completed' | 'error'`) when `statuses` is omitted,
+     * so active tasks are preserved.
+     * Returns the list of removed taskIds (caller broadcasts `task:deleted` per id).
+     */
+    clear(options?: {
+        projectPath?: string;
+        statuses?: TaskHistoryStatus[];
+    }): Promise<{
+        deletedCount: number;
+        taskIds: string[];
+    }>;
+    /** Remove a single entry by taskId. Idempotent — returns false on missing/already-deleted. */
+    delete(taskId: string): Promise<boolean>;
+    /**
+     * Bulk-delete by taskIds. Returns the subset of input ids that were live
+     * (and have now been tombstoned) — invalid, unknown, and already-tombstoned
+     * ids are dropped. Callers can rely on the returned array length as the
+     * `deletedCount` and on the array contents for per-id broadcasts.
+     */
+    deleteMany(taskIds: string[]): Promise<string[]>;
+    /** Retrieve an entry's full Level 2 detail by taskId. Returns undefined if not found or corrupt. */
+    getById(taskId: string): Promise<TaskHistoryEntry | undefined>;
+    /**
+     * List entries (summary shape) sorted newest-first.
+     *
+     * Returns the wire-friendly `TaskListItem` shape — no `responseContent`, `toolCalls`,
+     * `reasoningContents`, `sessionId`, or `result`. Callers fetch full detail via `getById`.
+     *
+     * M2.16: param names align with the wire schema (`createdAfter` / `createdBefore`
+     * instead of legacy `after` / `before`). Pagination moved to the handler — store
+     * returns ALL matches; no `limit`.
+     *
+     * Note on `provider` / `model` / `status` filters: `handleTaskList` does NOT push
+     * these down — pivot filters run at the handler so derivative sets (counts,
+     * availableProviders, availableModels) can apply their exclusion rules. The
+     * options remain on the interface for direct store callers (tests, future CLI
+     * commands like `brv query-log`-style scans) that don't need pivot semantics.
+     */
+    list(options?: {
+        /** Include only entries with createdAt >= this epoch ms. */
+        createdAfter?: number;
+        /** Include only entries with createdAt <= this epoch ms. */
+        createdBefore?: number;
+        /** Include only entries matching these model ids. Direct-caller use only. */
+        model?: string[];
+        projectPath?: string;
+        /** Include only entries matching these provider ids. Direct-caller use only. */
+        provider?: string[];
+        /** Include only entries matching these statuses. Direct-caller use only. */
+        status?: TaskHistoryStatus[];
+        /** Include only entries matching these task types. */
+        type?: string[];
+    }): Promise<TaskListItem[]>;
+    /** Persist (create or overwrite) a history entry. Validates with Zod — throws on invalid shape. */
+    save(entry: TaskHistoryEntry): Promise<void>;
+}

package/dist/server/core/interfaces/storage/i-task-history-store.js

@@ -0,0 +1 @@
+export {};

package/dist/server/infra/billing/billing-state-endpoint.d.ts

@@ -0,0 +1,4 @@
+import type { BillingStateRequest, BillingStateResponse } from '../../core/domain/transport/schemas.js';
+import type { IBillingConfigStore } from '../../core/interfaces/storage/i-billing-config-store.js';
+export type BillingConfigStoreFactory = (projectPath: string) => IBillingConfigStore;
+export declare function createBillingStateHandler(storeFactory: BillingConfigStoreFactory): (data: BillingStateRequest) => Promise<BillingStateResponse>;

package/dist/server/infra/billing/billing-state-endpoint.js

@@ -0,0 +1,7 @@
+export function createBillingStateHandler(storeFactory) {
+    return async (data) => {
+        const store = storeFactory(data.projectPath);
+        const pinnedTeamId = await store.getPinnedTeamId();
+        return pinnedTeamId === undefined ? {} : { pinnedTeamId };
+    };
+}

package/dist/server/infra/billing/build-status-billing.d.ts

@@ -0,0 +1,9 @@
+import type { BillingFreeUserLimitDTO, BillingUsageDTO, StatusBillingDTO } from '../../../shared/transport/types/dto.js';
+export interface BuildStatusBillingInput {
+    activeProvider: string;
+    freeUserLimit?: BillingFreeUserLimitDTO;
+    isAuthenticated: boolean;
+    paidUsages: readonly BillingUsageDTO[];
+    pinnedTeamId?: string;
+}
+export declare function buildStatusBilling(input: BuildStatusBillingInput): StatusBillingDTO | undefined;

package/dist/server/infra/billing/build-status-billing.js

@@ -0,0 +1,36 @@
+import { resolveBillingTeamId } from './resolve-billing-team.js';
+const BYTEROVER_PROVIDER_ID = 'byterover';
+export function buildStatusBilling(input) {
+    if (!input.isAuthenticated)
+        return undefined;
+    if (input.activeProvider !== BYTEROVER_PROVIDER_ID) {
+        return { activeProvider: input.activeProvider, source: 'other-provider' };
+    }
+    const paidIds = input.paidUsages.map((u) => u.organizationId);
+    const resolved = resolveBillingTeamId({
+        paidOrganizationIds: paidIds,
+        pinnedTeamId: input.pinnedTeamId,
+    });
+    if (resolved === undefined)
+        return freeSource(input.freeUserLimit);
+    const usage = input.paidUsages.find((u) => u.organizationId === resolved);
+    if (!usage)
+        return { organizationId: resolved, source: 'paid' };
+    return {
+        organizationId: usage.organizationId,
+        organizationName: usage.organizationName,
+        remaining: usage.remaining,
+        source: 'paid',
+        tier: usage.tier,
+        total: usage.totalLimit,
+    };
+}
+function freeSource(freeLimit) {
+    if (!freeLimit)
+        return { source: 'free' };
+    return {
+        remaining: freeLimit.monthly.remaining,
+        source: 'free',
+        total: freeLimit.monthly.limit,
+    };
+}

package/dist/server/infra/billing/http-billing-service.d.ts

@@ -0,0 +1,19 @@
+import type { BillingFreeUserLimitDTO, BillingOrganizationTierDTO, BillingUsageDTO } from '../../../shared/transport/types/dto.js';
+import type { IBillingService } from '../../core/interfaces/services/i-billing-service.js';
+export type BillingServiceConfig = {
+    apiBaseUrl: string;
+    timeout?: number;
+};
+/**
+ * HTTP-backed billing service. `getUsages` joins `/billing/usages` and
+ * `/billing/organizations/tiers` in parallel so consumers see tier alongside
+ * credit usage in a single DTO. `getFreeUserLimit` mirrors its endpoint 1:1.
+ */
+export declare class HttpBillingService implements IBillingService {
+    private readonly config;
+    constructor(config: BillingServiceConfig);
+    getFreeUserLimit(sessionKey: string): Promise<BillingFreeUserLimitDTO>;
+    getTiers(sessionKey: string): Promise<BillingOrganizationTierDTO[]>;
+    getUsages(sessionKey: string): Promise<BillingUsageDTO[]>;
+    private fetchRawUsages;
+}

package/dist/server/infra/billing/http-billing-service.js

@@ -0,0 +1,57 @@
+import { getErrorMessage } from '../../utils/error-helpers.js';
+import { AuthenticatedHttpClient } from '../http/authenticated-http-client.js';
+const DEFAULT_TIMEOUT_MS = 10_000;
+/**
+ * HTTP-backed billing service. `getUsages` joins `/billing/usages` and
+ * `/billing/organizations/tiers` in parallel so consumers see tier alongside
+ * credit usage in a single DTO. `getFreeUserLimit` mirrors its endpoint 1:1.
+ */
+export class HttpBillingService {
+    config;
+    constructor(config) {
+        this.config = {
+            apiBaseUrl: config.apiBaseUrl,
+            timeout: config.timeout ?? DEFAULT_TIMEOUT_MS,
+        };
+    }
+    async getFreeUserLimit(sessionKey) {
+        try {
+            const httpClient = new AuthenticatedHttpClient(sessionKey);
+            const url = `${this.config.apiBaseUrl}/billing/usage/free-user/limit`;
+            return await httpClient.get(url, { timeout: this.config.timeout });
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch free-user limit: ${getErrorMessage(error)}`);
+        }
+    }
+    async getTiers(sessionKey) {
+        try {
+            const httpClient = new AuthenticatedHttpClient(sessionKey);
+            const url = `${this.config.apiBaseUrl}/billing/organizations/tiers`;
+            const response = await httpClient.get(url, { timeout: this.config.timeout });
+            return response.organizations;
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch billing tiers: ${getErrorMessage(error)}`);
+        }
+    }
+    async getUsages(sessionKey) {
+        const [rawUsages, tiers] = await Promise.all([this.fetchRawUsages(sessionKey), this.getTiers(sessionKey)]);
+        const tierByOrg = new Map(tiers.map((t) => [t.organizationId, t]));
+        return rawUsages.map((usage) => {
+            const tier = tierByOrg.get(usage.organizationId);
+            return { ...usage, isTrialing: tier?.isTrialing ?? false, tier: tier?.tier ?? 'FREE' };
+        });
+    }
+    async fetchRawUsages(sessionKey) {
+        try {
+            const httpClient = new AuthenticatedHttpClient(sessionKey);
+            const url = `${this.config.apiBaseUrl}/billing/usages`;
+            const response = await httpClient.get(url, { timeout: this.config.timeout });
+            return response.organizations;
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch billing usages: ${getErrorMessage(error)}`);
+        }
+    }
+}

package/dist/server/infra/billing/paid-organizations-endpoint.d.ts

@@ -0,0 +1,8 @@
+import type { PaidOrganizationsResponse } from '../../core/domain/transport/schemas.js';
+import type { IBillingService } from '../../core/interfaces/services/i-billing-service.js';
+import type { IAuthStateStore } from '../../core/interfaces/state/i-auth-state-store.js';
+export interface PaidOrganizationsHandlerDeps {
+    authStateStore: IAuthStateStore;
+    billingService: IBillingService;
+}
+export declare function createPaidOrganizationsHandler(deps: PaidOrganizationsHandlerDeps): () => Promise<PaidOrganizationsResponse>;

package/dist/server/infra/billing/paid-organizations-endpoint.js

@@ -0,0 +1,18 @@
+import { getErrorMessage } from '../../utils/error-helpers.js';
+export function createPaidOrganizationsHandler(deps) {
+    return async () => {
+        const token = deps.authStateStore.getToken();
+        if (!token?.isValid())
+            return { organizationIds: [] };
+        try {
+            const tiers = await deps.billingService.getTiers(token.sessionKey);
+            const organizationIds = tiers
+                .filter((tier) => tier.tier !== 'FREE')
+                .map((tier) => tier.organizationId);
+            return { organizationIds };
+        }
+        catch (error) {
+            return { error: getErrorMessage(error), organizationIds: [] };
+        }
+    };
+}

package/dist/server/infra/billing/resolve-billing-source.d.ts

@@ -0,0 +1,13 @@
+import type { StatusBillingDTO } from '../../../shared/transport/types/dto.js';
+import type { IProviderConfigStore } from '../../core/interfaces/i-provider-config-store.js';
+import type { IBillingService } from '../../core/interfaces/services/i-billing-service.js';
+import type { IAuthStateStore } from '../../core/interfaces/state/i-auth-state-store.js';
+import type { IBillingConfigStore } from '../../core/interfaces/storage/i-billing-config-store.js';
+export interface ResolveBillingDeps {
+    authStateStore: IAuthStateStore;
+    billingConfigStoreFactory: (projectPath: string) => IBillingConfigStore;
+    billingService: IBillingService;
+    projectPath: string;
+    providerConfigStore: IProviderConfigStore;
+}
+export declare function resolveBillingForProject(deps: ResolveBillingDeps): Promise<StatusBillingDTO | undefined>;

package/dist/server/infra/billing/resolve-billing-source.js

@@ -0,0 +1,36 @@
+import { buildStatusBilling } from './build-status-billing.js';
+const BYTEROVER_PROVIDER_ID = 'byterover';
+export async function resolveBillingForProject(deps) {
+    const activeProvider = await deps.providerConfigStore.getActiveProvider().catch(() => '');
+    const token = deps.authStateStore.getToken();
+    if (!token?.isValid()) {
+        return buildStatusBilling({ activeProvider, isAuthenticated: false, paidUsages: [] });
+    }
+    if (activeProvider !== BYTEROVER_PROVIDER_ID) {
+        return buildStatusBilling({ activeProvider, isAuthenticated: true, paidUsages: [] });
+    }
+    const { sessionKey } = token;
+    const [pinnedTeamId, usagesResult] = await Promise.all([
+        deps
+            .billingConfigStoreFactory(deps.projectPath)
+            .getPinnedTeamId()
+            .catch(() => undefined),
+        deps.billingService
+            .getUsages(sessionKey)
+            .then((usages) => ({ ok: true, usages }))
+            .catch(() => ({ ok: false })),
+    ]);
+    if (!usagesResult.ok)
+        return undefined;
+    const paidUsages = usagesResult.usages.filter((u) => u.tier !== 'FREE');
+    const freeUserLimit = paidUsages.length === 0
+        ? await deps.billingService.getFreeUserLimit(sessionKey).catch(() => undefined)
+        : undefined;
+    return buildStatusBilling({
+        activeProvider,
+        freeUserLimit,
+        isAuthenticated: true,
+        paidUsages,
+        pinnedTeamId,
+    });
+}

package/dist/server/infra/billing/resolve-billing-team.d.ts

@@ -0,0 +1,5 @@
+export interface BillingTeamResolverInput {
+    paidOrganizationIds: readonly string[];
+    pinnedTeamId?: string;
+}
+export declare function resolveBillingTeamId(input: BillingTeamResolverInput): string | undefined;

package/dist/server/infra/billing/resolve-billing-team.js

@@ -0,0 +1,8 @@
+export function resolveBillingTeamId(input) {
+    const { paidOrganizationIds, pinnedTeamId } = input;
+    if (pinnedTeamId)
+        return pinnedTeamId;
+    if (paidOrganizationIds.length === 1)
+        return paidOrganizationIds[0];
+    return undefined;
+}