monomind 1.10.56 → 1.11.0

package/packages/@monomind/cli/dist/src/production/monitoring.d.ts

@@ -8,9 +8,15 @@
  * - Health checks
  * - Alerting
  *
- * @module @monoes/cli/production/monitoring
+ * @module @monomind/cli/production/monitoring
  */
-export type MetricType = 'counter' | 'gauge' | 'histogram' | 'summary';
+/** Metric type discriminator. */
+export type MetricType = 'counter' | 'gauge' | 'histogram';
+/** Alert severity level. */
+export type AlertLevel = 'warning' | 'critical';
+/** Health check status discriminator. */
+export type HealthCheckStatus = 'healthy' | 'unhealthy';
+/** A single recorded metric event. */
 export interface MetricEvent {
     name: string;
     type: MetricType;
@@ -18,29 +24,53 @@ export interface MetricEvent {
     labels: Record<string, string>;
     timestamp: number;
 }
+/** Warning/critical thresholds for a single metric. */
+export interface AlertThreshold {
+    warning: number;
+    critical: number;
+}
+/** Configuration for the monitoring hooks. */
 export interface MonitorConfig {
     enabled: boolean;
     retentionMs: number;
     maxMetrics: number;
     samplingRate: number;
-    alertThresholds: Record<string, {
-        warning: number;
-        critical: number;
-    }>;
+    alertThresholds: Record<string, AlertThreshold>;
     healthCheckIntervalMs: number;
-    reportingEndpoint?: string;
     globalLabels: Record<string, string>;
 }
+/** An active or acknowledged alert. */
+export interface Alert {
+    id: string;
+    level: AlertLevel;
+    metric: string;
+    message: string;
+    value: number;
+    threshold: number;
+    timestamp: number;
+    acknowledged: boolean;
+}
+/** Result returned by a registered health check function. */
+export interface HealthCheckResult {
+    healthy: boolean;
+    message?: string;
+}
+/** A user-supplied health check. */
+export type HealthCheck = () => Promise<HealthCheckResult>;
+/** Per-check entry within an aggregated health status. */
+export interface HealthCheckEntry {
+    status: HealthCheckStatus;
+    message?: string;
+    lastCheck: number;
+    responseTimeMs: number;
+}
+/** Aggregated health status across all registered checks. */
 export interface HealthStatus {
     healthy: boolean;
-    checks: Record<string, {
-        status: 'healthy' | 'degraded' | 'unhealthy';
-        message?: string;
-        lastCheck: number;
-        responseTimeMs?: number;
-    }>;
+    checks: Record<string, HealthCheckEntry>;
     timestamp: number;
 }
+/** Snapshot of performance metrics derived from recorded data. */
 export interface PerformanceMetrics {
     requestCount: number;
     errorCount: number;
@@ -52,17 +82,14 @@ export interface PerformanceMetrics {
     activeRequests: number;
     uptime: number;
 }
-type AlertLevel = 'info' | 'warning' | 'critical';
-interface Alert {
-    id: string;
-    level: AlertLevel;
-    metric: string;
-    message: string;
-    value: number;
-    threshold: number;
-    timestamp: number;
-    acknowledged: boolean;
+/** Aggregated summary entry for a single metric name. */
+export interface MetricSummaryEntry {
+    count: number;
+    lastValue: number;
+    avgValue: number;
 }
+/** Function returned by {@link MonitoringHooks.startRequest} to end tracking. */
+export type EndRequest = () => void;
 export declare class MonitoringHooks {
     private config;
     private metrics;
@@ -90,11 +117,11 @@ export declare class MonitoringHooks {
     /**
      * Record a metric event
      */
-    private recordMetric;
+    recordMetric(name: string, type: MetricType, value: number, labels: Record<string, string>): void;
     /**
      * Start tracking a request
      */
-    startRequest(requestId: string): () => void;
+    startRequest(requestId?: string): EndRequest;
     /**
      * Record an error
      */
@@ -102,10 +129,7 @@ export declare class MonitoringHooks {
     /**
      * Register a health check
      */
-    registerHealthCheck(name: string, check: () => Promise<{
-        healthy: boolean;
-        message?: string;
-    }>): void;
+    registerHealthCheck(name: string, check: HealthCheck): void;
     /**
      * Run all health checks
      */
@@ -137,11 +161,7 @@ export declare class MonitoringHooks {
     /**
      * Get all metrics summary
      */
-    getMetricsSummary(): Record<string, {
-        count: number;
-        lastValue: number;
-        avgValue: number;
-    }>;
+    getMetricsSummary(): Record<string, MetricSummaryEntry>;
     /**
      * Reset all metrics
      */

package/packages/@monomind/cli/dist/src/production/monitoring.js

@@ -19,9 +19,9 @@ const DEFAULT_CONFIG = {
     maxMetrics: 100000,
     samplingRate: 1.0,
     alertThresholds: {
-        'error_rate': { warning: 0.05, critical: 0.1 },
-        'response_time_ms': { warning: 1000, critical: 5000 },
-        'active_requests': { warning: 100, critical: 500 },
+        error_rate: { warning: 0.05, critical: 0.1 },
+        response_time_ms: { warning: 1000, critical: 5000 },
+        active_requests: { warning: 100, critical: 500 },
     },
     healthCheckIntervalMs: 30000,
     globalLabels: {},
@@ -190,9 +190,7 @@ export class MonitoringHooks {
             const index = Math.ceil(count * p) - 1;
             return sortedTimes[Math.min(index, count - 1)];
         };
-        const avgResponseTime = count > 0
-            ? sortedTimes.reduce((a, b) => a + b, 0) / count
-            : 0;
+        const avgResponseTime = count > 0 ? sortedTimes.reduce((a, b) => a + b, 0) / count : 0;
         return {
             requestCount: this.requestCount,
             errorCount: this.errorCount,
@@ -212,9 +210,9 @@ export class MonitoringHooks {
      * Get active alerts
      */
     getAlerts(level) {
-        let filtered = this.alerts.filter(a => !a.acknowledged);
+        let filtered = this.alerts.filter((a) => !a.acknowledged);
         if (level) {
-            filtered = filtered.filter(a => a.level === level);
+            filtered = filtered.filter((a) => a.level === level);
         }
         return filtered;
     }
@@ -222,7 +220,7 @@ export class MonitoringHooks {
      * Acknowledge an alert
      */
     acknowledgeAlert(alertId) {
-        const alert = this.alerts.find(a => a.id === alertId);
+        const alert = this.alerts.find((a) => a.id === alertId);
         if (alert) {
             alert.acknowledged = true;
             return true;
@@ -242,9 +240,9 @@ export class MonitoringHooks {
      * Get metrics for a specific name
      */
     getMetrics(name, since) {
-        let filtered = this.metrics.filter(m => m.name === name);
+        let filtered = this.metrics.filter((m) => m.name === name);
         if (since) {
-            filtered = filtered.filter(m => m.timestamp >= since);
+            filtered = filtered.filter((m) => m.timestamp >= since);
         }
         return filtered;
     }
@@ -302,7 +300,7 @@ export class MonitoringHooks {
         }
         if (level) {
             // Check if we already have a recent alert for this metric
-            const recentAlert = this.alerts.find(a => a.metric === name &&
+            const recentAlert = this.alerts.find((a) => a.metric === name &&
                 !a.acknowledged &&
                 Date.now() - a.timestamp < 60000);
             if (!recentAlert) {
@@ -323,13 +321,13 @@ export class MonitoringHooks {
         const now = Date.now();
         const cutoff = now - this.config.retentionMs;
         // Remove old metrics
-        this.metrics = this.metrics.filter(m => m.timestamp > cutoff);
+        this.metrics = this.metrics.filter((m) => m.timestamp > cutoff);
         // Limit total metrics
         if (this.metrics.length > this.config.maxMetrics) {
             this.metrics = this.metrics.slice(-this.config.maxMetrics);
         }
         // Remove old acknowledged alerts
-        this.alerts = this.alerts.filter(a => !a.acknowledged || Date.now() - a.timestamp < 300000);
+        this.alerts = this.alerts.filter((a) => !a.acknowledged || Date.now() - a.timestamp < 300000);
         // Cap total alerts to prevent unbounded growth
         const MAX_ALERTS = 500;
         if (this.alerts.length > MAX_ALERTS) {

package/packages/@monomind/cli/dist/src/production/rate-limiter.d.ts

@@ -7,26 +7,83 @@
  * - Burst allowance
  * - Sliding window tracking
  *
- * @module @monoes/cli/production/rate-limiter
+ * @module @monomind/cli/production/rate-limiter
+ */
+/**
+ * Per-operation rate limit override.
+ */
+export interface OperationLimit {
+    /** Maximum number of requests allowed within the window. */
+    maxRequests: number;
+    /** Window size in milliseconds. */
+    windowMs: number;
+}
+/**
+ * Rate limiter configuration. All fields are optional when constructing —
+ * unspecified values fall back to {@link DEFAULT_CONFIG}.
  */
 export interface RateLimiterConfig {
+    /** Default maximum requests per window. */
     maxRequests: number;
+    /** Default window size in milliseconds. */
     windowMs: number;
+    /** Multiplier applied for burst allowance. */
     burstMultiplier: number;
+    /** Operations that bypass rate limiting entirely. */
     whitelist: string[];
-    operationLimits: Record<string, {
-        maxRequests: number;
-        windowMs: number;
-    }>;
+    /** Per-operation limit overrides keyed by operation name. */
+    operationLimits: Record<string, OperationLimit>;
+    /** Whether to track limits per user/agent in addition to per operation. */
     perUserLimits: boolean;
+    /** Maximum number of distinct buckets to retain before eviction. */
     maxTrackedUsers: number;
 }
+/**
+ * Result of a rate limit check.
+ */
 export interface RateLimitResult {
+    /** Whether the request is permitted. */
     allowed: boolean;
+    /** Remaining requests in the current window. */
     remaining: number;
+    /** Epoch timestamp (ms) at which the window resets. */
     resetAt: number;
+    /** When rate limited, milliseconds to wait before retrying. */
     retryAfterMs?: number;
 }
+/**
+ * Snapshot of the current rate limit state for a key.
+ */
+export interface RateLimitStatus {
+    /** Number of requests counted in the current window. */
+    current: number;
+    /** Configured limit for the operation. */
+    limit: number;
+    /** Remaining requests in the current window. */
+    remaining: number;
+    /** Epoch timestamp (ms) at which the window resets. */
+    resetAt: number;
+}
+/**
+ * Aggregate operation usage entry used in statistics.
+ */
+export interface OperationStat {
+    /** Operation name. */
+    operation: string;
+    /** Total requests counted across buckets for the operation. */
+    requests: number;
+}
+/**
+ * Aggregate rate limiter statistics.
+ */
+export interface RateLimiterStats {
+    /** Total number of active buckets. */
+    totalBuckets: number;
+    /** Number of distinct users currently tracked. */
+    activeUsers: number;
+    /** Top operations by request volume. */
+    mostLimitedOperations: OperationStat[];
+}
 export declare class RateLimiter {
     private config;
     private buckets;
@@ -43,12 +100,7 @@ export declare class RateLimiter {
     /**
      * Get current rate limit status
      */
-    getStatus(operation: string, userId?: string): {
-        current: number;
-        limit: number;
-        remaining: number;
-        resetAt: number;
-    };
+    getStatus(operation: string, userId?: string): RateLimitStatus;
     /**
      * Reset limits for a specific key
      */
@@ -60,14 +112,7 @@ export declare class RateLimiter {
     /**
      * Get statistics
      */
-    getStats(): {
-        totalBuckets: number;
-        activeUsers: number;
-        mostLimitedOperations: Array<{
-            operation: string;
-            requests: number;
-        }>;
-    };
+    getStats(): RateLimiterStats;
     private getLimits;
     private createBucket;
     private cleanupBuckets;

package/packages/@monomind/cli/dist/src/production/rate-limiter.js

@@ -51,7 +51,7 @@ export class RateLimiter {
             this.cleanupBuckets();
         }
         // Clean old requests from sliding window
-        bucket.requests = bucket.requests.filter(t => t > now - limits.windowMs);
+        bucket.requests = bucket.requests.filter((t) => t > now - limits.windowMs);
         // Calculate remaining — uses base maxRequests (consistent with getStatus())
         const remaining = limits.maxRequests - bucket.requests.length;
         if (remaining <= 0) {
@@ -100,7 +100,7 @@ export class RateLimiter {
             };
         }
         // Clean old requests
-        const validRequests = bucket.requests.filter(t => t > now - limits.windowMs);
+        const validRequests = bucket.requests.filter((t) => t > now - limits.windowMs);
         return {
             current: validRequests.length,
             limit: limits.maxRequests,
@@ -157,10 +157,10 @@ export class RateLimiter {
     // Private Methods
     // ============================================================================
     getLimits(operation) {
-        return this.config.operationLimits[operation] || {
+        return (this.config.operationLimits[operation] || {
             maxRequests: this.config.maxRequests,
             windowMs: this.config.windowMs,
-        };
+        });
     }
     createBucket() {
         return {
@@ -178,7 +178,7 @@ export class RateLimiter {
         for (const [key, bucket] of this.buckets) {
             if (this.buckets.size <= target)
                 break;
-            const recent = bucket.requests.filter(t => t > now - this.config.windowMs * 2);
+            const recent = bucket.requests.filter((t) => t > now - this.config.windowMs * 2);
             if (recent.length === 0)
                 this.buckets.delete(key);
         }

package/packages/@monomind/cli/dist/src/production/retry.js

@@ -45,7 +45,9 @@ function calculateDelay(attempt, config, strategy = 'exponential') {
             break;
         case 'exponential':
         default:
-            delay = config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt - 1);
+            delay =
+                config.initialDelayMs *
+                    Math.pow(config.backoffMultiplier, attempt - 1);
     }
     // Apply max delay cap
     delay = Math.min(delay, config.maxDelayMs);
@@ -90,7 +92,7 @@ function shouldRetryError(error, attempt, config) {
  * Sleep for a given number of milliseconds
  */
 function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }
 /**
  * Execute a function with retry logic

package/packages/@monomind/cli/dist/src/runtime/headless.d.ts

@@ -4,9 +4,9 @@
  * Runs without TTY for daemon processes and scheduled tasks
  *
  * Usage:
- *   npx @monoes/cli headless --worker <type>
- *   npx @monoes/cli headless --daemon
- *   npx @monoes/cli headless --benchmark
+ *   npx @monomind/cli headless --worker <type>
+ *   npx @monomind/cli headless --daemon
+ *   npx @monomind/cli headless --benchmark
  *
  * Environment:
  *   MONOMIND_HEADLESS=true

package/packages/@monomind/cli/dist/src/services/claim-service.d.ts

@@ -12,19 +12,20 @@
  *
  * @see /packages/implementation/adrs/ADR-016-collaborative-issue-claims.md
  */
-import { EventEmitter } from 'events';
-export type Claimant = {
+import { EventEmitter } from 'node:events';
+export type ClaimStatus = 'active' | 'paused' | 'handoff-pending' | 'review-requested' | 'blocked' | 'stealable' | 'completed';
+export interface HumanClaimant {
     type: 'human';
     userId: string;
     name: string;
-} | {
+}
+export interface AgentClaimant {
     type: 'agent';
     agentId: string;
     agentType: string;
-};
-export type ClaimStatus = 'active' | 'paused' | 'handoff-pending' | 'review-requested' | 'blocked' | 'stealable' | 'completed';
-export type StealReason = 'overloaded' | 'stale' | 'blocked-timeout' | 'voluntary';
-export interface IssueClaim {
+}
+export type Claimant = HumanClaimant | AgentClaimant;
+export interface Claim {
     issueId: string;
     claimant: Claimant;
     claimedAt: Date;
@@ -38,48 +39,53 @@ export interface IssueClaim {
     context?: string;
 }
 export interface StealableInfo {
-    reason: StealReason;
+    reason: string;
     stealableAt: Date;
-    preferredTypes?: string[];
     progress: number;
     context?: string;
+    preferredTypes?: string[];
 }
 export interface ClaimResult {
     success: boolean;
-    claim?: IssueClaim;
+    claim?: Claim;
     error?: string;
 }
 export interface StealResult {
     success: boolean;
-    claim?: IssueClaim;
+    claim?: Claim;
     previousOwner?: Claimant;
     context?: StealableInfo;
     error?: string;
 }
-export interface AgentLoadInfo {
+export interface AgentLoad {
     agentId: string;
     agentType: string;
     claimCount: number;
     maxClaims: number;
     utilization: number;
-    claims: IssueClaim[];
+    claims: Claim[];
     avgCompletionTime: number;
     currentBlockedCount: number;
 }
+export interface RebalanceSuggestion {
+    issueId: string;
+    currentOwner: Claimant;
+    suggestedOwner: Claimant;
+    reason: string;
+}
 export interface RebalanceResult {
-    moved: Array<{
-        issueId: string;
-        from: Claimant;
-        to: Claimant;
-    }>;
-    suggested: Array<{
-        issueId: string;
-        currentOwner: Claimant;
-        suggestedOwner: Claimant;
-        reason: string;
-    }>;
-}
-export interface WorkStealingConfig {
+    moved: string[];
+    suggested: RebalanceSuggestion[];
+}
+export interface ClaimEvent {
+    type: string;
+    timestamp: Date;
+    issueId: string;
+    claimant?: Claimant;
+    previousClaimant?: Claimant;
+    data?: Record<string, unknown>;
+}
+export interface ClaimServiceConfig {
     staleThresholdMinutes: number;
     blockedThresholdMinutes: number;
     overloadThreshold: number;
@@ -89,12 +95,6 @@ export interface WorkStealingConfig {
     requireSameType: boolean;
     allowCrossTypeSteal: string[][];
 }
-export interface IssueFilters {
-    status?: ClaimStatus[];
-    labels?: string[];
-    agentTypes?: string[];
-    priority?: string[];
-}
 export interface GitHubIssue {
     number: number;
     title: string;
@@ -108,35 +108,26 @@ export interface GitHubIssue {
 }
 export interface GitHubSyncConfig {
     enabled: boolean;
-    repo?: string;
     syncLabels: boolean;
     claimLabel: string;
     autoAssign: boolean;
     commentOnClaim: boolean;
     commentOnRelease: boolean;
+    repo?: string;
 }
-export interface GitHubSyncResult {
+export interface SyncResult {
     success: boolean;
     synced: number;
     errors: string[];
     issues?: GitHubIssue[];
 }
-export type ClaimEventType = 'issue:claimed' | 'issue:released' | 'issue:handoff:requested' | 'issue:handoff:accepted' | 'issue:handoff:rejected' | 'issue:status:changed' | 'issue:review:requested' | 'issue:expired' | 'issue:stealable' | 'issue:stolen' | 'issue:steal:contested' | 'issue:steal:resolved' | 'swarm:rebalanced' | 'agent:overloaded' | 'agent:underloaded';
-export interface ClaimEvent {
-    type: ClaimEventType;
-    timestamp: Date;
-    issueId?: string;
-    claimant?: Claimant;
-    previousClaimant?: Claimant;
-    data?: Record<string, unknown>;
-}
 export declare class ClaimService extends EventEmitter {
     private claims;
     private stealableInfo;
     private storagePath;
     private config;
     private eventLog;
-    constructor(projectRoot: string, config?: Partial<WorkStealingConfig>);
+    constructor(projectRoot: string, config?: Partial<ClaimServiceConfig>);
     initialize(): Promise<void>;
     private loadClaims;
     private _saveQueue;
@@ -149,19 +140,19 @@ export declare class ClaimService extends EventEmitter {
     rejectHandoff(issueId: string, claimant: Claimant, reason: string): Promise<void>;
     updateStatus(issueId: string, status: ClaimStatus, note?: string): Promise<void>;
     updateProgress(issueId: string, progress: number): Promise<void>;
-    requestReview(issueId: string, reviewers: Claimant[]): Promise<void>;
+    requestReview(issueId: string, reviewers: string[]): Promise<void>;
     markStealable(issueId: string, info: StealableInfo, claimant?: Claimant): Promise<void>;
     steal(issueId: string, stealer: Claimant): Promise<StealResult>;
-    getStealable(agentType?: string): Promise<IssueClaim[]>;
+    getStealable(agentType?: string): Promise<Claim[]>;
     contestSteal(issueId: string, originalClaimant: Claimant, reason: string): Promise<void>;
-    getAgentLoad(agentId: string): Promise<AgentLoadInfo>;
-    rebalance(swarmId: string): Promise<RebalanceResult>;
-    getClaimedBy(claimant: Claimant): Promise<IssueClaim[]>;
-    getAvailableIssues(_filters?: IssueFilters): Promise<string[]>;
-    getIssueStatus(issueId: string): Promise<IssueClaim | null>;
-    getAllClaims(): Promise<IssueClaim[]>;
-    getByStatus(status: ClaimStatus): Promise<IssueClaim[]>;
-    expireStale(maxAgeMinutes?: number): Promise<IssueClaim[]>;
+    getAgentLoad(agentId: string): Promise<AgentLoad>;
+    rebalance(_swarmId: string): Promise<RebalanceResult>;
+    getClaimedBy(claimant: Claimant): Promise<Claim[]>;
+    getAvailableIssues(_filters?: unknown): Promise<GitHubIssue[]>;
+    getIssueStatus(issueId: string): Promise<Claim | null>;
+    getAllClaims(): Promise<Claim[]>;
+    getByStatus(status: ClaimStatus): Promise<Claim[]>;
+    expireStale(maxAgeMinutes?: number): Promise<Claim[]>;
     private formatClaimant;
     private isSameClaimant;
     private emitEvent;
@@ -182,25 +173,25 @@ export declare class GitHubSync {
     /**
      * Sync issues from GitHub
      */
-    syncIssues(state?: 'open' | 'closed' | 'all'): Promise<GitHubSyncResult>;
+    syncIssues(state?: 'open' | 'closed' | 'all'): Promise<SyncResult>;
     /**
      * Sync a local claim to GitHub (add label/assignee/comment)
      */
-    claimOnGitHub(issueNumber: number, claimant: Claimant): Promise<GitHubSyncResult>;
+    claimOnGitHub(issueNumber: number, claimant: Claimant): Promise<SyncResult>;
     /**
      * Release claim on GitHub (remove label/assignee/comment)
      */
-    releaseOnGitHub(issueNumber: number, claimant: Claimant): Promise<GitHubSyncResult>;
+    releaseOnGitHub(issueNumber: number, claimant: Claimant): Promise<SyncResult>;
     /**
      * Bulk sync all local claims to GitHub
      */
-    syncAllClaimsToGitHub(): Promise<GitHubSyncResult>;
+    syncAllClaimsToGitHub(): Promise<SyncResult>;
     /**
      * Get GitHub issues that are claimed locally
      */
     getClaimedGitHubIssues(): Promise<GitHubIssue[]>;
 }
-export declare function createClaimService(projectRoot: string, config?: Partial<WorkStealingConfig>): ClaimService;
+export declare function createClaimService(projectRoot: string, config?: Partial<ClaimServiceConfig>): ClaimService;
 export declare function createGitHubSync(claimService: ClaimService, config?: Partial<GitHubSyncConfig>): GitHubSync;
 export default ClaimService;
 //# sourceMappingURL=claim-service.d.ts.map