@agent-relay/cloud 0.1.0

package/dist/services/persistence.js

@@ -0,0 +1,200 @@
+/**
+ * Cloud Persistence Service
+ *
+ * Handles durable persistence of agent session data for cloud deployments.
+ * Subscribes to wrapper events ('summary', 'session-end') and persists
+ * to PostgreSQL via Drizzle ORM.
+ *
+ * This decouples wrappers from storage concerns - the wrapper emits events,
+ * this service handles persistence. Different storage backends can be swapped
+ * by implementing alternative persistence services.
+ *
+ * @see RelayPtyOrchestratorEvents in src/wrapper/relay-pty-orchestrator.ts for event definitions
+ */
+import { eq, and, desc } from 'drizzle-orm';
+import { getDb } from '../db/drizzle.js';
+import { agentSessions, agentSummaries } from '../db/schema.js';
+/**
+ * CloudPersistenceService manages durable storage for agent sessions.
+ *
+ * Usage:
+ * ```typescript
+ * const persistence = new CloudPersistenceService({
+ *   workspaceId: 'workspace-123',
+ * });
+ *
+ * // Bind to a RelayPtyOrchestrator instance
+ * const pty = new RelayPtyOrchestrator(config);
+ * const sessionId = await persistence.bindToWrapper(pty);
+ *
+ * // When done, unbind to clean up listeners
+ * persistence.unbindFromWrapper(pty);
+ * ```
+ */
+export class CloudPersistenceService {
+    config;
+    boundWrappers = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Bind to a RelayPtyOrchestrator instance and start persisting its events.
+     * Creates a new agent session record and returns the session ID.
+     *
+     * @param wrapper The RelayPtyOrchestrator to bind to
+     * @returns The session ID for this agent session
+     */
+    async bindToRelayPtyOrchestrator(wrapper) {
+        const db = getDb();
+        const agentName = wrapper.name;
+        // Create session record
+        const result = await db.insert(agentSessions).values({
+            workspaceId: this.config.workspaceId,
+            agentName,
+            status: 'active',
+            startedAt: new Date(),
+        }).returning();
+        const session = result[0];
+        if (!session) {
+            throw new Error(`Failed to create session for agent ${agentName}`);
+        }
+        const sessionId = session.id;
+        // Create event handlers
+        const summaryHandler = async (event) => {
+            await this.handleSummary(sessionId, event);
+        };
+        const sessionEndHandler = async (event) => {
+            await this.handleSessionEnd(sessionId, event);
+        };
+        // Bind handlers
+        wrapper.on('summary', summaryHandler);
+        wrapper.on('session-end', sessionEndHandler);
+        // Track binding for cleanup
+        this.boundWrappers.set(wrapper, {
+            sessionId,
+            summaryHandler,
+            sessionEndHandler,
+        });
+        console.log(`[persistence] Bound to ${agentName}, session=${sessionId}`);
+        return sessionId;
+    }
+    /**
+     * Unbind from a RelayPtyOrchestrator and clean up event listeners.
+     *
+     * @param wrapper The RelayPtyOrchestrator to unbind from
+     */
+    unbindFromRelayPtyOrchestrator(wrapper) {
+        const binding = this.boundWrappers.get(wrapper);
+        if (!binding)
+            return;
+        wrapper.off('summary', binding.summaryHandler);
+        wrapper.off('session-end', binding.sessionEndHandler);
+        this.boundWrappers.delete(wrapper);
+        console.log(`[persistence] Unbound from ${wrapper.name}`);
+    }
+    /**
+     * Handle a summary event - persist to agent_summaries table.
+     */
+    async handleSummary(sessionId, event) {
+        try {
+            const db = getDb();
+            const result = await db.insert(agentSummaries).values({
+                sessionId,
+                agentName: event.agentName,
+                summary: event.summary,
+                createdAt: new Date(),
+            }).returning();
+            const summaryRecord = result[0];
+            if (!summaryRecord) {
+                console.error(`[persistence] Insert returned no record for ${event.agentName}`);
+                return;
+            }
+            console.log(`[persistence] Saved summary for ${event.agentName}: ${event.summary.currentTask || 'no task'}`);
+            this.config.onSummaryPersisted?.(event.agentName, summaryRecord.id);
+        }
+        catch (err) {
+            console.error(`[persistence] Failed to save summary for ${event.agentName}:`, err);
+        }
+    }
+    /**
+     * Handle a session-end event - update agent_sessions with end marker.
+     */
+    async handleSessionEnd(sessionId, event) {
+        try {
+            const db = getDb();
+            await db.update(agentSessions)
+                .set({
+                status: 'ended',
+                endedAt: new Date(),
+                endMarker: event.marker,
+            })
+                .where(eq(agentSessions.id, sessionId));
+            console.log(`[persistence] Session ended for ${event.agentName}: ${event.marker.summary || 'no summary'}`);
+            this.config.onSessionEnded?.(event.agentName, sessionId);
+        }
+        catch (err) {
+            console.error(`[persistence] Failed to end session for ${event.agentName}:`, err);
+        }
+    }
+    /**
+     * Get the session ID for a bound wrapper.
+     */
+    getSessionId(wrapper) {
+        return this.boundWrappers.get(wrapper)?.sessionId;
+    }
+    /**
+     * Get all summaries for a session.
+     */
+    async getSessionSummaries(sessionId) {
+        const db = getDb();
+        return db.select()
+            .from(agentSummaries)
+            .where(eq(agentSummaries.sessionId, sessionId))
+            .orderBy(agentSummaries.createdAt);
+    }
+    /**
+     * Get the latest summary for an agent in THIS workspace.
+     * Joins through agent_sessions to ensure workspace scoping.
+     */
+    async getLatestSummary(agentName) {
+        const db = getDb();
+        // Join with sessions to ensure we only get summaries from this workspace
+        const results = await db.select({
+            id: agentSummaries.id,
+            sessionId: agentSummaries.sessionId,
+            agentName: agentSummaries.agentName,
+            summary: agentSummaries.summary,
+            createdAt: agentSummaries.createdAt,
+        })
+            .from(agentSummaries)
+            .innerJoin(agentSessions, eq(agentSummaries.sessionId, agentSessions.id))
+            .where(and(eq(agentSummaries.agentName, agentName), eq(agentSessions.workspaceId, this.config.workspaceId)))
+            .orderBy(desc(agentSummaries.createdAt))
+            .limit(1);
+        return results[0] || null;
+    }
+    /**
+     * Get active sessions for a workspace.
+     */
+    async getActiveSessions() {
+        const db = getDb();
+        return db.select()
+            .from(agentSessions)
+            .where(and(eq(agentSessions.workspaceId, this.config.workspaceId), eq(agentSessions.status, 'active')));
+    }
+    /**
+     * Clean up all bindings.
+     */
+    destroy() {
+        for (const wrapper of this.boundWrappers.keys()) {
+            this.unbindFromRelayPtyOrchestrator(wrapper);
+        }
+    }
+}
+/**
+ * Factory function to create a persistence service for a workspace.
+ */
+export function createPersistenceService(workspaceId) {
+    return new CloudPersistenceService({ workspaceId });
+}
+//# sourceMappingURL=persistence.js.map

package/dist/services/persistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.js","sourceRoot":"","sources":["../../src/services/persistence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAG5C,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAchE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,uBAAuB;IAC1B,MAAM,CAAyB;IAC/B,aAAa,GAAG,IAAI,GAAG,EAI3B,CAAC;IAEL,YAAY,MAA8B;QACxC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,0BAA0B,CAAC,OAA6B;QAC5D,MAAM,EAAE,GAAG,KAAK,EAAE,CAAC;QACnB,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;QAE/B,wBAAwB;QACxB,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC;YACnD,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,WAAW;YACpC,SAAS;YACT,MAAM,EAAE,QAAQ;YAChB,SAAS,EAAE,IAAI,IAAI,EAAE;SACtB,CAAC,CAAC,SAAS,EAAE,CAAC;QAEf,MAAM,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QAC1B,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,sCAAsC,SAAS,EAAE,CAAC,CAAC;QACrE,CAAC;QACD,MAAM,SAAS,GAAG,OAAO,CAAC,EAAE,CAAC;QAE7B,wBAAwB;QACxB,MAAM,cAAc,GAAG,KAAK,EAAE,KAAmB,EAAE,EAAE;YACnD,MAAM,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAC7C,CAAC,CAAC;QAEF,MAAM,iBAAiB,GAAG,KAAK,EAAE,KAAsB,EAAE,EAAE;YACzD,MAAM,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAChD,CAAC,CAAC;QAEF,gBAAgB;QAChB,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;QACtC,OAAO,CAAC,EAAE,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;QAE7C,4BAA4B;QAC5B,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,EAAE;YAC9B,SAAS;YACT,cAAc;YACd,iBAAiB;SAClB,CAAC,CAAC;QAEH,OAAO,CAAC,GAAG,CAAC,0BAA0B,SAAS,aAAa,SAAS,EAAE,CAAC,CAAC;QACzE,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;;;OAIG;IACH,8BAA8B,CAAC,OAA6B;QAC1D,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAChD,IAAI,CAAC,OAAO;YAAE,OAAO;QAErB,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;QAC/C,OAAO,CAAC,GAAG,CAAC,aAAa,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;QACtD,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAEnC,OAAO,CAAC,GAAG,CAAC,8BAA8B,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IAC5D,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,aAAa,CAAC,SAAiB,EAAE,KAAmB;QAChE,IAAI,CAAC;YACH,MAAM,EAAE,GAAG,KAAK,EAAE,CAAC;YAEnB,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,MAAM,CAAC;gBACpD,SAAS;gBACT,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,SAAS,EAAE,IAAI,IAAI,EAAE;aACtB,CAAC,CAAC,SAAS,EAAE,CAAC;YAEf,MAAM,aAAa,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YAChC,IAAI,CAAC,aAAa,EAAE,CAAC;gBACnB,OAAO,CAAC,KAAK,CAAC,+CAA+C,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC;gBAChF,OAAO;YACT,CAAC;YAED,OAAO,CAAC,GAAG,CAAC,mCAAmC,KAAK,CAAC,SAAS,KAAK,KAAK,CAAC,OAAO,CAAC,WAAW,IAAI,SAAS,EAAE,CAAC,CAAC;YAE7G,IAAI,CAAC,MAAM,CAAC,kBAAkB,EAAE,CAAC,KAAK,CAAC,SAAS,EAAE,aAAa,CAAC,EAAE,CAAC,CAAC;QACtE,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,KAAK,CAAC,4CAA4C,KAAK,CAAC,SAAS,GAAG,EAAE,GAAG,CAAC,CAAC;QACrF,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,gBAAgB,CAAC,SAAiB,EAAE,KAAsB;QACtE,IAAI,CAAC;YACH,MAAM,EAAE,GAAG,KAAK,EAAE,CAAC;YAEnB,MAAM,EAAE,CAAC,MAAM,CAAC,aAAa,CAAC;iBAC3B,GAAG,CAAC;gBACH,MAAM,EAAE,OAAO;gBACf,OAAO,EAAE,IAAI,IAAI,EAAE;gBACnB,SAAS,EAAE,KAAK,CAAC,MAAM;aACxB,CAAC;iBACD,KAAK,CAAC,EAAE,CAAC,aAAa,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC;YAE1C,OAAO,CAAC,GAAG,CAAC,mCAAmC,KAAK,CAAC,SAAS,KAAK,KAAK,CAAC,MAAM,CAAC,OAAO,IAAI,YAAY,EAAE,CAAC,CAAC;YAE3G,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QAC3D,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,KAAK,CAAC,2CAA2C,KAAK,CAAC,SAAS,GAAG,EAAE,GAAG,CAAC,CAAC;QACpF,CAAC;IACH,CAAC;IAED;;OAEG;IACH,YAAY,CAAC,OAA6B;QACxC,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC;IACpD,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,mBAAmB,CAAC,SAAiB;QACzC,MAAM,EAAE,GAAG,KAAK,EAAE,CAAC;QACnB,OAAO,EAAE,CAAC,MAAM,EAAE;aACf,IAAI,CAAC,cAAc,CAAC;aACpB,KAAK,CAAC,EAAE,CAAC,cAAc,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;aAC9C,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,gBAAgB,CAAC,SAAiB;QACtC,MAAM,EAAE,GAAG,KAAK,EAAE,CAAC;QACnB,yEAAyE;QACzE,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC,MAAM,CAAC;YAC9B,EAAE,EAAE,cAAc,CAAC,EAAE;YACrB,SAAS,EAAE,cAAc,CAAC,SAAS;YACnC,SAAS,EAAE,cAAc,CAAC,SAAS;YACnC,OAAO,EAAE,cAAc,CAAC,OAAO;YAC/B,SAAS,EAAE,cAAc,CAAC,SAAS;SACpC,CAAC;aACC,IAAI,CAAC,cAAc,CAAC;aACpB,SAAS,CAAC,aAAa,EAAE,EAAE,CAAC,cAAc,CAAC,SAAS,EAAE,aAAa,CAAC,EAAE,CAAC,CAAC;aACxE,KAAK,CAAC,GAAG,CACR,EAAE,CAAC,cAAc,CAAC,SAAS,EAAE,SAAS,CAAC,EACvC,EAAE,CAAC,aAAa,CAAC,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CACvD,CAAC;aACD,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;aACvC,KAAK,CAAC,CAAC,CAAC,CAAC;QACZ,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;IAC5B,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,iBAAiB;QACrB,MAAM,EAAE,GAAG,KAAK,EAAE,CAAC;QACnB,OAAO,EAAE,CAAC,MAAM,EAAE;aACf,IAAI,CAAC,aAAa,CAAC;aACnB,KAAK,CAAC,GAAG,CACR,EAAE,CAAC,aAAa,CAAC,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,EACtD,EAAE,CAAC,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,CACnC,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACH,OAAO;QACL,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,EAAE,CAAC;YAChD,IAAI,CAAC,8BAA8B,CAAC,OAAO,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC;CACF;AAED;;GAEG;AACH,MAAM,UAAU,wBAAwB,CAAC,WAAmB;IAC1D,OAAO,IAAI,uBAAuB,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC;AACtD,CAAC"}

package/dist/services/planLimits.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Plan Limits Service
+ *
+ * Defines resource limits for each plan tier and provides
+ * functions to check if users are within their limits.
+ */
+import { PlanType } from '../db/index.js';
+/**
+ * Resource limits for each plan tier
+ */
+export interface PlanLimits {
+    maxWorkspaces: number;
+    maxRepos: number;
+    maxConcurrentAgents: number;
+    maxComputeHoursPerMonth: number;
+    coordinatorsEnabled: boolean;
+    /** Cloud session persistence (summaries, session tracking) - Pro+ only */
+    sessionPersistence: boolean;
+}
+/**
+ * Plan limits configuration
+ *
+ * Free: Try it out on a side project
+ * Pro: Professional developers, coordinators enabled
+ * Team: Growing teams with advanced needs
+ * Enterprise: Unlimited everything
+ */
+export declare const PLAN_LIMITS: Record<PlanType, PlanLimits>;
+/**
+ * Get plan limits for a given plan type
+ */
+export declare function getPlanLimits(plan: PlanType): PlanLimits;
+/**
+ * Current usage for a user
+ */
+export interface UserUsage {
+    workspaceCount: number;
+    repoCount: number;
+    concurrentAgents: number;
+    computeHoursThisMonth: number;
+}
+/**
+ * Get current usage for a user
+ */
+export declare function getUserUsage(userId: string): Promise<UserUsage>;
+/**
+ * Check if user can create a new workspace
+ */
+export declare function canCreateWorkspace(userId: string): Promise<{
+    allowed: boolean;
+    reason?: string;
+    limit?: number;
+    current?: number;
+}>;
+/**
+ * Check if user can add a new repo
+ */
+export declare function canAddRepo(userId: string): Promise<{
+    allowed: boolean;
+    reason?: string;
+    limit?: number;
+    current?: number;
+}>;
+/**
+ * Check if user can spawn another agent (concurrent agent limit)
+ */
+export declare function canSpawnAgent(userId: string, currentRunningAgents?: number): Promise<{
+    allowed: boolean;
+    reason?: string;
+    limit?: number;
+    current?: number;
+}>;
+/**
+ * Check if user can use coordinator agents
+ */
+export declare function canUseCoordinator(userId: string): Promise<{
+    allowed: boolean;
+    reason?: string;
+    requiredPlan?: string;
+}>;
+/**
+ * Check if user can use cloud session persistence
+ *
+ * Session persistence enables:
+ * - [[SUMMARY]] blocks saved to cloud database
+ * - [[SESSION_END]] markers for session tracking
+ * - Session recovery and handoff between agents
+ */
+export declare function canUseSessionPersistence(userId: string): Promise<{
+    allowed: boolean;
+    reason?: string;
+    requiredPlan?: string;
+}>;
+/**
+ * Check if user has compute hours available
+ */
+export declare function hasComputeHoursAvailable(userId: string): Promise<{
+    available: boolean;
+    reason?: string;
+    limit?: number;
+    current?: number;
+}>;
+/**
+ * Get remaining quota for a user
+ */
+export declare function getRemainingQuota(userId: string): Promise<{
+    plan: PlanType;
+    limits: PlanLimits;
+    usage: UserUsage;
+    remaining: {
+        workspaces: number;
+        repos: number;
+        concurrentAgents: number;
+        computeHours: number;
+    };
+}>;
+/**
+ * Record compute usage
+ */
+export declare function recordComputeUsage(userId: string, workspaceId: string, hours: number): Promise<void>;
+/**
+ * Update active agent count for a user
+ */
+export declare function updateActiveAgentCount(userId: string, workspaceId: string, count: number): Promise<void>;
+/**
+ * Resource tier name type
+ */
+export type ResourceTierName = 'small' | 'medium' | 'large' | 'xlarge';
+/**
+ * Get the default resource tier for a plan
+ * Maps plans to appropriate compute resources
+ */
+export declare function getResourceTierForPlan(plan: PlanType): ResourceTierName;
+/**
+ * Get the maximum resource tier a plan can scale to
+ * Prevents over-scaling beyond plan entitlements
+ */
+export declare function getMaxResourceTierForPlan(plan: PlanType): ResourceTierName;
+/**
+ * Check if user's plan allows auto-scaling
+ */
+export declare function canAutoScale(plan: PlanType): boolean;
+/**
+ * Check if auto-scale to a specific tier is allowed for a plan
+ */
+export declare function canScaleToTier(plan: PlanType, targetTier: ResourceTierName): boolean;
+//# sourceMappingURL=planLimits.d.ts.map

package/dist/services/planLimits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planLimits.d.ts","sourceRoot":"","sources":["../../src/services/planLimits.ts"],"names":[],"mappings":"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"}

package/dist/services/planLimits.js

@@ -0,0 +1,335 @@
+/**
+ * Plan Limits Service
+ *
+ * Defines resource limits for each plan tier and provides
+ * functions to check if users are within their limits.
+ */
+import { db, usageRecordsTable } from '../db/index.js';
+import { eq, and, gte, sql } from 'drizzle-orm';
+import { getDb } from '../db/drizzle.js';
+/**
+ * Plan limits configuration
+ *
+ * Free: Try it out on a side project
+ * Pro: Professional developers, coordinators enabled
+ * Team: Growing teams with advanced needs
+ * Enterprise: Unlimited everything
+ */
+export const PLAN_LIMITS = {
+    free: {
+        maxWorkspaces: 1,
+        maxRepos: 2,
+        maxConcurrentAgents: 2,
+        maxComputeHoursPerMonth: 5, // Limited free tier
+        coordinatorsEnabled: false,
+        sessionPersistence: false,
+    },
+    pro: {
+        maxWorkspaces: 5,
+        maxRepos: 10,
+        maxConcurrentAgents: 5,
+        maxComputeHoursPerMonth: 50,
+        coordinatorsEnabled: true,
+        sessionPersistence: true,
+    },
+    team: {
+        maxWorkspaces: 20,
+        maxRepos: 100,
+        maxConcurrentAgents: 50,
+        maxComputeHoursPerMonth: 500,
+        coordinatorsEnabled: true,
+        sessionPersistence: true,
+    },
+    enterprise: {
+        maxWorkspaces: Infinity,
+        maxRepos: Infinity,
+        maxConcurrentAgents: Infinity,
+        maxComputeHoursPerMonth: Infinity,
+        coordinatorsEnabled: true,
+        sessionPersistence: true,
+    },
+};
+/**
+ * Get plan limits for a given plan type
+ */
+export function getPlanLimits(plan) {
+    return PLAN_LIMITS[plan];
+}
+/**
+ * Get current usage for a user
+ */
+export async function getUserUsage(userId) {
+    // Get workspace count
+    const workspaces = await db.workspaces.findByUserId(userId);
+    const workspaceCount = workspaces.length;
+    // Get repo count across all workspaces
+    let repoCount = 0;
+    for (const workspace of workspaces) {
+        const repos = await db.repositories.findByWorkspaceId(workspace.id);
+        repoCount += repos.length;
+    }
+    // Get concurrent agents (currently running)
+    // For now, we'll track this via usage_records with metric 'active_agents'
+    // In production, this would query the actual running agent count
+    const drizzleDb = getDb();
+    const activeAgentsResult = await drizzleDb
+        .select({ total: sql `COALESCE(MAX(${usageRecordsTable.value}), 0)` })
+        .from(usageRecordsTable)
+        .where(and(eq(usageRecordsTable.userId, userId), eq(usageRecordsTable.metric, 'active_agents')));
+    const concurrentAgents = Number(activeAgentsResult[0]?.total || 0);
+    // Get compute hours this month
+    const startOfMonth = new Date();
+    startOfMonth.setDate(1);
+    startOfMonth.setHours(0, 0, 0, 0);
+    const computeHoursResult = await drizzleDb
+        .select({ total: sql `COALESCE(SUM(${usageRecordsTable.value}), 0)` })
+        .from(usageRecordsTable)
+        .where(and(eq(usageRecordsTable.userId, userId), eq(usageRecordsTable.metric, 'compute_hours'), gte(usageRecordsTable.recordedAt, startOfMonth)));
+    const computeHoursThisMonth = Number(computeHoursResult[0]?.total || 0);
+    return {
+        workspaceCount,
+        repoCount,
+        concurrentAgents,
+        computeHoursThisMonth,
+    };
+}
+/**
+ * Check if user can create a new workspace
+ */
+export async function canCreateWorkspace(userId) {
+    const user = await db.users.findById(userId);
+    if (!user) {
+        return { allowed: false, reason: 'User not found' };
+    }
+    const plan = user.plan || 'free';
+    const limits = getPlanLimits(plan);
+    const usage = await getUserUsage(userId);
+    if (usage.workspaceCount >= limits.maxWorkspaces) {
+        return {
+            allowed: false,
+            reason: `Workspace limit reached for ${plan} plan`,
+            limit: limits.maxWorkspaces,
+            current: usage.workspaceCount,
+        };
+    }
+    return { allowed: true };
+}
+/**
+ * Check if user can add a new repo
+ */
+export async function canAddRepo(userId) {
+    const user = await db.users.findById(userId);
+    if (!user) {
+        return { allowed: false, reason: 'User not found' };
+    }
+    const plan = user.plan || 'free';
+    const limits = getPlanLimits(plan);
+    const usage = await getUserUsage(userId);
+    if (usage.repoCount >= limits.maxRepos) {
+        return {
+            allowed: false,
+            reason: `Repository limit reached for ${plan} plan`,
+            limit: limits.maxRepos,
+            current: usage.repoCount,
+        };
+    }
+    return { allowed: true };
+}
+/**
+ * Check if user can spawn another agent (concurrent agent limit)
+ */
+export async function canSpawnAgent(userId, currentRunningAgents) {
+    const user = await db.users.findById(userId);
+    if (!user) {
+        return { allowed: false, reason: 'User not found' };
+    }
+    const plan = user.plan || 'free';
+    const limits = getPlanLimits(plan);
+    // Use provided count or fetch from usage
+    let concurrentAgents;
+    if (currentRunningAgents !== undefined) {
+        concurrentAgents = currentRunningAgents;
+    }
+    else {
+        const usage = await getUserUsage(userId);
+        concurrentAgents = usage.concurrentAgents;
+    }
+    if (concurrentAgents >= limits.maxConcurrentAgents) {
+        return {
+            allowed: false,
+            reason: `Concurrent agent limit reached for ${plan} plan`,
+            limit: limits.maxConcurrentAgents,
+            current: concurrentAgents,
+        };
+    }
+    return { allowed: true };
+}
+/**
+ * Check if user can use coordinator agents
+ */
+export async function canUseCoordinator(userId) {
+    const user = await db.users.findById(userId);
+    if (!user) {
+        return { allowed: false, reason: 'User not found' };
+    }
+    const plan = user.plan || 'free';
+    const limits = getPlanLimits(plan);
+    if (!limits.coordinatorsEnabled) {
+        return {
+            allowed: false,
+            reason: 'Coordinator agents require a Pro plan or higher',
+            requiredPlan: 'pro',
+        };
+    }
+    return { allowed: true };
+}
+/**
+ * Check if user can use cloud session persistence
+ *
+ * Session persistence enables:
+ * - [[SUMMARY]] blocks saved to cloud database
+ * - [[SESSION_END]] markers for session tracking
+ * - Session recovery and handoff between agents
+ */
+export async function canUseSessionPersistence(userId) {
+    const user = await db.users.findById(userId);
+    if (!user) {
+        return { allowed: false, reason: 'User not found' };
+    }
+    const plan = user.plan || 'free';
+    const limits = getPlanLimits(plan);
+    if (!limits.sessionPersistence) {
+        return {
+            allowed: false,
+            reason: 'Cloud session persistence requires a Pro plan or higher',
+            requiredPlan: 'pro',
+        };
+    }
+    return { allowed: true };
+}
+/**
+ * Check if user has compute hours available
+ */
+export async function hasComputeHoursAvailable(userId) {
+    const user = await db.users.findById(userId);
+    if (!user) {
+        return { available: false, reason: 'User not found' };
+    }
+    const plan = user.plan || 'free';
+    const limits = getPlanLimits(plan);
+    const usage = await getUserUsage(userId);
+    // Enterprise has unlimited
+    if (limits.maxComputeHoursPerMonth === Infinity) {
+        return { available: true };
+    }
+    if (usage.computeHoursThisMonth >= limits.maxComputeHoursPerMonth) {
+        return {
+            available: false,
+            reason: `Compute hours limit reached for ${plan} plan`,
+            limit: limits.maxComputeHoursPerMonth,
+            current: usage.computeHoursThisMonth,
+        };
+    }
+    return { available: true };
+}
+/**
+ * Get remaining quota for a user
+ */
+export async function getRemainingQuota(userId) {
+    const user = await db.users.findById(userId);
+    const plan = (user?.plan || 'free');
+    const limits = getPlanLimits(plan);
+    const usage = await getUserUsage(userId);
+    const calcRemaining = (limit, current) => limit === Infinity ? Infinity : Math.max(0, limit - current);
+    return {
+        plan,
+        limits,
+        usage,
+        remaining: {
+            workspaces: calcRemaining(limits.maxWorkspaces, usage.workspaceCount),
+            repos: calcRemaining(limits.maxRepos, usage.repoCount),
+            concurrentAgents: calcRemaining(limits.maxConcurrentAgents, usage.concurrentAgents),
+            computeHours: calcRemaining(limits.maxComputeHoursPerMonth, usage.computeHoursThisMonth),
+        },
+    };
+}
+/**
+ * Record compute usage
+ */
+export async function recordComputeUsage(userId, workspaceId, hours) {
+    const drizzleDb = getDb();
+    await drizzleDb.insert(usageRecordsTable).values({
+        userId,
+        workspaceId,
+        metric: 'compute_hours',
+        value: Math.round(hours * 100) / 100, // Round to 2 decimal places
+        recordedAt: new Date(),
+    });
+}
+/**
+ * Update active agent count for a user
+ */
+export async function updateActiveAgentCount(userId, workspaceId, count) {
+    const drizzleDb = getDb();
+    await drizzleDb.insert(usageRecordsTable).values({
+        userId,
+        workspaceId,
+        metric: 'active_agents',
+        value: count,
+        recordedAt: new Date(),
+    });
+}
+/**
+ * Get the default resource tier for a plan
+ * Maps plans to appropriate compute resources
+ */
+export function getResourceTierForPlan(plan) {
+    switch (plan) {
+        case 'free':
+            return 'small'; // 2GB, 2 CPUs - suitable for 2 agents
+        case 'pro':
+            return 'medium'; // 4GB, 4 CPUs - suitable for 5 agents
+        case 'team':
+            return 'large'; // 8GB, 4 CPUs - suitable for 10 agents
+        case 'enterprise':
+            return 'xlarge'; // 16GB, 8 CPUs - suitable for 20 agents
+        default:
+            return 'small';
+    }
+}
+/**
+ * Get the maximum resource tier a plan can scale to
+ * Prevents over-scaling beyond plan entitlements
+ */
+export function getMaxResourceTierForPlan(plan) {
+    switch (plan) {
+        case 'free':
+            return 'small'; // Free tier cannot scale up
+        case 'pro':
+            return 'medium'; // Pro can scale to medium
+        case 'team':
+            return 'large'; // Team can scale to large
+        case 'enterprise':
+            return 'xlarge'; // Enterprise can use any tier
+        default:
+            return 'small';
+    }
+}
+/**
+ * Check if user's plan allows auto-scaling
+ */
+export function canAutoScale(plan) {
+    // Only Pro and above can auto-scale
+    return plan !== 'free';
+}
+/**
+ * Check if auto-scale to a specific tier is allowed for a plan
+ */
+export function canScaleToTier(plan, targetTier) {
+    const tierOrder = ['small', 'medium', 'large', 'xlarge'];
+    const maxTier = getMaxResourceTierForPlan(plan);
+    const targetIndex = tierOrder.indexOf(targetTier);
+    const maxIndex = tierOrder.indexOf(maxTier);
+    return targetIndex <= maxIndex;
+}
+//# sourceMappingURL=planLimits.js.map