memorix 1.2.1 → 1.2.2

package/src/store/project-affinity.ts

@@ -1,195 +1,195 @@
-/**
- * Project Affinity Scoring
- *
- * Prevents cross-project memory pollution by scoring search results
- * based on how well they match the current project context.
- *
- * Inspired by mcp-memory-service's memory-scorer.js:
- * - High affinity: content mentions project name → full score
- * - Medium affinity: related concepts but no direct mention → 0.7x
- * - Low affinity: no project reference → 0.3x (heavily penalized)
- *
- * This runs AFTER projectId filtering, as a second layer of defense
- * against memories that were stored under the correct projectId but
- * contain content about a different project (e.g., discussing Memorix
- * development while in a test project workspace).
- */
-
-export interface AffinityContext {
-  /** Current project name (e.g., "for_memmcp_test", "memorix") */
-  projectName: string;
-  /** Current project ID (e.g., "local/for_memmcp_test", "AVIDS2/memorix") */
-  projectId: string;
-  /** Optional: keywords that indicate project relevance */
-  projectKeywords?: string[];
-}
-
-export interface MemoryContent {
-  title: string;
-  narrative?: string;
-  facts?: string[];
-  concepts?: string[];
-  entityName?: string;
-  filesModified?: string[];
-}
-
-export interface AffinityResult {
-  /** Affinity score 0-1 (1 = high affinity, 0 = no affinity) */
-  score: number;
-  /** Affinity level for debugging */
-  level: 'high' | 'medium' | 'low' | 'none';
-  /** Reason for the score */
-  reason: string;
-}
-
-/**
- * Calculate project affinity score for a memory.
- *
- * @param memory - The memory content to evaluate
- * @param context - Current project context
- * @returns AffinityResult with score, level, and reason
- */
-export function calculateProjectAffinity(
-  memory: MemoryContent,
-  context: AffinityContext,
-): AffinityResult {
-  const projectName = context.projectName.toLowerCase();
-  const projectId = context.projectId.toLowerCase();
-  
-  // Extract base name from projectId (e.g., "memorix" from "AVIDS2/memorix")
-  const projectBaseName = projectId.split('/').pop() ?? projectName;
-  
-  // Build searchable content string
-  const contentParts = [
-    memory.title,
-    memory.narrative ?? '',
-    memory.entityName ?? '',
-    ...(memory.facts ?? []),
-    ...(memory.concepts ?? []),
-    ...(memory.filesModified ?? []),
-  ];
-  const content = contentParts.join(' ').toLowerCase();
-  
-  // Check for direct project name mention
-  if (content.includes(projectName) || content.includes(projectBaseName)) {
-    return { score: 1.0, level: 'high', reason: 'project_name_in_content' };
-  }
-  
-  // Check for project keywords (if provided)
-  if (context.projectKeywords && context.projectKeywords.length > 0) {
-    const keywordsLower = context.projectKeywords.map(k => k.toLowerCase());
-    const matchedKeywords = keywordsLower.filter(k => content.includes(k));
-    if (matchedKeywords.length >= 2) {
-      return { score: 0.9, level: 'high', reason: `keywords_matched: ${matchedKeywords.join(', ')}` };
-    }
-    if (matchedKeywords.length === 1) {
-      return { score: 0.7, level: 'medium', reason: `keyword_matched: ${matchedKeywords[0]}` };
-    }
-  }
-  
-  // Check for file paths that suggest project relevance
-  const files = memory.filesModified ?? [];
-  if (files.some(f => f.toLowerCase().includes(projectName) || f.toLowerCase().includes(projectBaseName))) {
-    return { score: 0.85, level: 'high', reason: 'project_in_file_path' };
-  }
-  
-  // Check entity name
-  if (memory.entityName) {
-    const entityLower = memory.entityName.toLowerCase();
-    if (entityLower.includes(projectName) || entityLower.includes(projectBaseName)) {
-      return { score: 0.8, level: 'high', reason: 'project_in_entity' };
-    }
-  }
-  
-  // Check concepts for project-related terms
-  const concepts = memory.concepts ?? [];
-  if (concepts.some(c => c.toLowerCase().includes(projectName) || c.toLowerCase().includes(projectBaseName))) {
-    return { score: 0.75, level: 'medium', reason: 'project_in_concepts' };
-  }
-  
-  // No project reference found — this memory might be about a different project
-  // Apply penalty but don't completely filter (might still be relevant)
-  return { score: 0.65, level: 'low', reason: 'no_project_reference' };
-}
-
-/**
- * Apply project affinity scoring to search results.
- *
- * @param results - Search results with scores
- * @param memories - Full memory content for each result (keyed by ID)
- * @param context - Current project context
- * @param options - Scoring options
- * @returns Results with adjusted scores, sorted by affinity-weighted score
- */
-export function applyProjectAffinity<T extends { id: number; score: number }>(
-  results: T[],
-  memories: Map<number, MemoryContent>,
-  context: AffinityContext,
-  options: {
-    /** Minimum affinity score to include (default: 0, include all) */
-    minAffinity?: number;
-    /** Whether to filter out low-affinity results entirely (default: false) */
-    filterLowAffinity?: boolean;
-  } = {},
-): T[] {
-  const { minAffinity = 0, filterLowAffinity = false } = options;
-  
-  // Calculate affinity for each result
-  const withAffinity = results.map(result => {
-    const memory = memories.get(result.id);
-    if (!memory) {
-      // No memory content available — assume medium affinity
-      return { ...result, affinity: 0.5, affinityLevel: 'medium' as const };
-    }
-    
-    const { score: affinityScore, level } = calculateProjectAffinity(memory, context);
-    return {
-      ...result,
-      score: result.score * affinityScore, // Apply affinity as multiplier
-      affinity: affinityScore,
-      affinityLevel: level,
-    };
-  });
-  
-  // Filter by minimum affinity if requested
-  let filtered = withAffinity;
-  if (filterLowAffinity) {
-    filtered = withAffinity.filter(r => r.affinity >= 0.5);
-  } else if (minAffinity > 0) {
-    filtered = withAffinity.filter(r => r.affinity >= minAffinity);
-  }
-  
-  // Re-sort by affinity-weighted score
-  filtered.sort((a, b) => b.score - a.score);
-  
-  // Return without the extra affinity fields (keep original shape)
-  return filtered.map(({ affinity: _, affinityLevel: __, ...rest }) => rest as T);
-}
-
-/**
- * Extract project keywords from project name and common patterns.
- * Used to improve affinity detection for projects with distinctive names.
- */
-export function extractProjectKeywords(projectName: string, projectId: string): string[] {
-  const keywords: string[] = [projectName];
-  
-  // Add base name from projectId
-  const baseName = projectId.split('/').pop();
-  if (baseName && baseName !== projectName) {
-    keywords.push(baseName);
-  }
-  
-  // Add common variations
-  const variations = [
-    projectName.replace(/-/g, '_'),
-    projectName.replace(/_/g, '-'),
-    projectName.replace(/[_-]/g, ''),
-  ];
-  for (const v of variations) {
-    if (v !== projectName && !keywords.includes(v)) {
-      keywords.push(v);
-    }
-  }
-  
-  return keywords.filter(k => k.length > 2);
-}
+/**
+ * Project Affinity Scoring
+ *
+ * Prevents cross-project memory pollution by scoring search results
+ * based on how well they match the current project context.
+ *
+ * Inspired by mcp-memory-service's memory-scorer.js:
+ * - High affinity: content mentions project name → full score
+ * - Medium affinity: related concepts but no direct mention → 0.7x
+ * - Low affinity: no project reference → 0.3x (heavily penalized)
+ *
+ * This runs AFTER projectId filtering, as a second layer of defense
+ * against memories that were stored under the correct projectId but
+ * contain content about a different project (e.g., discussing Memorix
+ * development while in a test project workspace).
+ */
+
+export interface AffinityContext {
+  /** Current project name (e.g., "for_memmcp_test", "memorix") */
+  projectName: string;
+  /** Current project ID (e.g., "local/for_memmcp_test", "AVIDS2/memorix") */
+  projectId: string;
+  /** Optional: keywords that indicate project relevance */
+  projectKeywords?: string[];
+}
+
+export interface MemoryContent {
+  title: string;
+  narrative?: string;
+  facts?: string[];
+  concepts?: string[];
+  entityName?: string;
+  filesModified?: string[];
+}
+
+export interface AffinityResult {
+  /** Affinity score 0-1 (1 = high affinity, 0 = no affinity) */
+  score: number;
+  /** Affinity level for debugging */
+  level: 'high' | 'medium' | 'low' | 'none';
+  /** Reason for the score */
+  reason: string;
+}
+
+/**
+ * Calculate project affinity score for a memory.
+ *
+ * @param memory - The memory content to evaluate
+ * @param context - Current project context
+ * @returns AffinityResult with score, level, and reason
+ */
+export function calculateProjectAffinity(
+  memory: MemoryContent,
+  context: AffinityContext,
+): AffinityResult {
+  const projectName = context.projectName.toLowerCase();
+  const projectId = context.projectId.toLowerCase();
+  
+  // Extract base name from projectId (e.g., "memorix" from "AVIDS2/memorix")
+  const projectBaseName = projectId.split('/').pop() ?? projectName;
+  
+  // Build searchable content string
+  const contentParts = [
+    memory.title,
+    memory.narrative ?? '',
+    memory.entityName ?? '',
+    ...(memory.facts ?? []),
+    ...(memory.concepts ?? []),
+    ...(memory.filesModified ?? []),
+  ];
+  const content = contentParts.join(' ').toLowerCase();
+  
+  // Check for direct project name mention
+  if (content.includes(projectName) || content.includes(projectBaseName)) {
+    return { score: 1.0, level: 'high', reason: 'project_name_in_content' };
+  }
+  
+  // Check for project keywords (if provided)
+  if (context.projectKeywords && context.projectKeywords.length > 0) {
+    const keywordsLower = context.projectKeywords.map(k => k.toLowerCase());
+    const matchedKeywords = keywordsLower.filter(k => content.includes(k));
+    if (matchedKeywords.length >= 2) {
+      return { score: 0.9, level: 'high', reason: `keywords_matched: ${matchedKeywords.join(', ')}` };
+    }
+    if (matchedKeywords.length === 1) {
+      return { score: 0.7, level: 'medium', reason: `keyword_matched: ${matchedKeywords[0]}` };
+    }
+  }
+  
+  // Check for file paths that suggest project relevance
+  const files = memory.filesModified ?? [];
+  if (files.some(f => f.toLowerCase().includes(projectName) || f.toLowerCase().includes(projectBaseName))) {
+    return { score: 0.85, level: 'high', reason: 'project_in_file_path' };
+  }
+  
+  // Check entity name
+  if (memory.entityName) {
+    const entityLower = memory.entityName.toLowerCase();
+    if (entityLower.includes(projectName) || entityLower.includes(projectBaseName)) {
+      return { score: 0.8, level: 'high', reason: 'project_in_entity' };
+    }
+  }
+  
+  // Check concepts for project-related terms
+  const concepts = memory.concepts ?? [];
+  if (concepts.some(c => c.toLowerCase().includes(projectName) || c.toLowerCase().includes(projectBaseName))) {
+    return { score: 0.75, level: 'medium', reason: 'project_in_concepts' };
+  }
+  
+  // No project reference found — this memory might be about a different project
+  // Apply penalty but don't completely filter (might still be relevant)
+  return { score: 0.65, level: 'low', reason: 'no_project_reference' };
+}
+
+/**
+ * Apply project affinity scoring to search results.
+ *
+ * @param results - Search results with scores
+ * @param memories - Full memory content for each result (keyed by ID)
+ * @param context - Current project context
+ * @param options - Scoring options
+ * @returns Results with adjusted scores, sorted by affinity-weighted score
+ */
+export function applyProjectAffinity<T extends { id: number; score: number }>(
+  results: T[],
+  memories: Map<number, MemoryContent>,
+  context: AffinityContext,
+  options: {
+    /** Minimum affinity score to include (default: 0, include all) */
+    minAffinity?: number;
+    /** Whether to filter out low-affinity results entirely (default: false) */
+    filterLowAffinity?: boolean;
+  } = {},
+): T[] {
+  const { minAffinity = 0, filterLowAffinity = false } = options;
+  
+  // Calculate affinity for each result
+  const withAffinity = results.map(result => {
+    const memory = memories.get(result.id);
+    if (!memory) {
+      // No memory content available — assume medium affinity
+      return { ...result, affinity: 0.5, affinityLevel: 'medium' as const };
+    }
+    
+    const { score: affinityScore, level } = calculateProjectAffinity(memory, context);
+    return {
+      ...result,
+      score: result.score * affinityScore, // Apply affinity as multiplier
+      affinity: affinityScore,
+      affinityLevel: level,
+    };
+  });
+  
+  // Filter by minimum affinity if requested
+  let filtered = withAffinity;
+  if (filterLowAffinity) {
+    filtered = withAffinity.filter(r => r.affinity >= 0.5);
+  } else if (minAffinity > 0) {
+    filtered = withAffinity.filter(r => r.affinity >= minAffinity);
+  }
+  
+  // Re-sort by affinity-weighted score
+  filtered.sort((a, b) => b.score - a.score);
+  
+  // Return without the extra affinity fields (keep original shape)
+  return filtered.map(({ affinity: _, affinityLevel: __, ...rest }) => rest as T);
+}
+
+/**
+ * Extract project keywords from project name and common patterns.
+ * Used to improve affinity detection for projects with distinctive names.
+ */
+export function extractProjectKeywords(projectName: string, projectId: string): string[] {
+  const keywords: string[] = [projectName];
+  
+  // Add base name from projectId
+  const baseName = projectId.split('/').pop();
+  if (baseName && baseName !== projectName) {
+    keywords.push(baseName);
+  }
+  
+  // Add common variations
+  const variations = [
+    projectName.replace(/-/g, '_'),
+    projectName.replace(/_/g, '-'),
+    projectName.replace(/[_-]/g, ''),
+  ];
+  for (const v of variations) {
+    if (v !== projectName && !keywords.includes(v)) {
+      keywords.push(v);
+    }
+  }
+  
+  return keywords.filter(k => k.length > 2);
+}

package/src/store/sqlite-db.ts

@@ -57,7 +57,11 @@ CREATE TABLE IF NOT EXISTS observations (
   relatedCommits  TEXT,
   relatedEntities TEXT,
   sourceDetail    TEXT,
-  valueCategory   TEXT
+  valueCategory   TEXT,
+  admissionState  TEXT,
+  admissionReason TEXT,
+  visibility      TEXT,
+  sharedWithAgentIds TEXT
 );
 `;
 
@@ -529,6 +533,8 @@ CREATE INDEX IF NOT EXISTS idx_observations_projectId ON observations(projectId)
 CREATE INDEX IF NOT EXISTS idx_observations_topicKey ON observations(projectId, topicKey);
 CREATE INDEX IF NOT EXISTS idx_observations_status ON observations(status);
 CREATE INDEX IF NOT EXISTS idx_observations_project_status_id ON observations(projectId, status, id);
+CREATE INDEX IF NOT EXISTS idx_observations_project_admission ON observations(projectId, status, admissionState, id);
+CREATE INDEX IF NOT EXISTS idx_observations_project_visibility ON observations(projectId, status, visibility, id);
 CREATE INDEX IF NOT EXISTS idx_mini_skills_projectId ON mini_skills(projectId);
 CREATE INDEX IF NOT EXISTS idx_sessions_projectId ON sessions(projectId);
 CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(projectId, status);
@@ -590,6 +596,22 @@ function addColumnIfMissing(db: any, table: string, column: string, definition:
 }
 
 const SCHEMA_MIGRATIONS: SchemaMigration[] = [
+  {
+    id: '1.2.2-observation-admission',
+    apply: (db) => {
+      addColumnIfMissing(db, 'observations', 'admissionState', 'admissionState TEXT');
+      addColumnIfMissing(db, 'observations', 'admissionReason', 'admissionReason TEXT');
+      db.exec('CREATE INDEX IF NOT EXISTS idx_observations_project_admission ON observations(projectId, status, admissionState, id)');
+    },
+  },
+  {
+    id: '1.2.2-observation-visibility',
+    apply: (db) => {
+      addColumnIfMissing(db, 'observations', 'visibility', 'visibility TEXT');
+      addColumnIfMissing(db, 'observations', 'sharedWithAgentIds', 'sharedWithAgentIds TEXT');
+      db.exec('CREATE INDEX IF NOT EXISTS idx_observations_project_visibility ON observations(projectId, status, visibility, id)');
+    },
+  },
   {
     id: '1.2-code-state-snapshots',
     apply: (db) => {

package/src/store/sqlite-store.ts

@@ -49,6 +49,10 @@ function obsToRow(obs: Observation): Record<string, unknown> {
     relatedEntities: obs.relatedEntities ? JSON.stringify(obs.relatedEntities) : null,
     sourceDetail: obs.sourceDetail ?? null,
     valueCategory: obs.valueCategory ?? null,
+    admissionState: obs.admissionState ?? null,
+    admissionReason: obs.admissionReason ?? null,
+    visibility: obs.visibility ?? null,
+    sharedWithAgentIds: obs.sharedWithAgentIds ? JSON.stringify(obs.sharedWithAgentIds) : null,
     createdByAgentId: obs.createdByAgentId ?? null,
     writeGeneration: obs.writeGeneration ?? 0,
   };
@@ -80,6 +84,10 @@ function rowToObs(row: any): Observation {
     ...(row.relatedEntities ? { relatedEntities: safeJsonParse(row.relatedEntities, []) } : {}),
     ...(row.sourceDetail ? { sourceDetail: row.sourceDetail } : {}),
     ...(row.valueCategory ? { valueCategory: row.valueCategory } : {}),
+    ...(row.admissionState ? { admissionState: row.admissionState } : {}),
+    ...(row.admissionReason ? { admissionReason: row.admissionReason } : {}),
+    ...(row.visibility ? { visibility: row.visibility } : {}),
+    ...(row.sharedWithAgentIds ? { sharedWithAgentIds: safeJsonParse(row.sharedWithAgentIds, []) } : {}),
     ...(row.createdByAgentId ? { createdByAgentId: row.createdByAgentId } : {}),
     ...(row.writeGeneration ? { writeGeneration: row.writeGeneration } : {}),
   } as Observation;
@@ -132,12 +140,14 @@ export class SqliteBackend implements ObservationStore {
         (id, entityName, type, title, narrative, facts, filesModified, concepts, tokens,
          createdAt, updatedAt, projectId, hasCausalLanguage, topicKey, revisionCount,
          sessionId, status, progress, source, commitHash, relatedCommits, relatedEntities,
-         sourceDetail, valueCategory, createdByAgentId, writeGeneration)
+         sourceDetail, valueCategory, admissionState, admissionReason, visibility, sharedWithAgentIds,
+         createdByAgentId, writeGeneration)
       VALUES
         (@id, @entityName, @type, @title, @narrative, @facts, @filesModified, @concepts, @tokens,
          @createdAt, @updatedAt, @projectId, @hasCausalLanguage, @topicKey, @revisionCount,
          @sessionId, @status, @progress, @source, @commitHash, @relatedCommits, @relatedEntities,
-         @sourceDetail, @valueCategory, @createdByAgentId, @writeGeneration)
+         @sourceDetail, @valueCategory, @admissionState, @admissionReason, @visibility, @sharedWithAgentIds,
+         @createdByAgentId, @writeGeneration)
     `);
     this.stmtUpdate = this.stmtInsert; // INSERT OR REPLACE works for both
     this.stmtSetStatus = this.db.prepare(`UPDATE observations SET status = ? WHERE id = ?`);

package/src/team/event-bus.ts

@@ -1,76 +1,76 @@
-/**
- * TeamEventBus — Process-local typed event emitter for team coordination.
- *
- * Phase 4b: Provides push-based acceleration within a single process.
- * NOT a cross-process mechanism — the orchestrator uses SQLite polling.
- *
- * Architectural boundary (B1): This is process-local fanout only.
- * No persistence, no cross-process delivery, no durability guarantees.
- * If no listeners are registered, events are silently dropped.
- */
-
-import { EventEmitter } from 'node:events';
-
-// ── Event type map ─────────────────────────────────────────────────
-
-export interface TeamEventMap {
-  'task:created':   { taskId: string; projectId: string; description: string };
-  'task:claimed':   { taskId: string; projectId: string; agentId: string };
-  'task:completed': { taskId: string; projectId: string; agentId: string; result?: string };
-  'task:failed':    { taskId: string; projectId: string; agentId: string; result?: string };
-  'task:released':  { taskId: string; projectId: string; agentId: string };
-  'agent:joined':   { agentId: string; projectId: string; agentType: string };
-  'agent:left':     { agentId: string; projectId: string };
-  'agent:stale':    { agentId: string; projectId: string; releasedTasks: number };
-  'handoff:created':{ observationId: number; projectId: string; fromAgent: string; toAgent?: string; taskId?: string };
-}
-
-export type TeamEventName = keyof TeamEventMap;
-
-// ── TeamEventBus ───────────────────────────────────────────────────
-
-export class TeamEventBus {
-  private emitter = new EventEmitter();
-
-  constructor() {
-    // Prevent memory leak warnings for legitimate multi-listener scenarios
-    this.emitter.setMaxListeners(50);
-  }
-
-  /**
-   * Emit a typed event. Non-blocking, best-effort.
-   * If no listeners are registered, the event is silently dropped.
-   */
-  emit<K extends TeamEventName>(event: K, data: TeamEventMap[K]): void {
-    try {
-      this.emitter.emit(event, data);
-    } catch {
-      // Best-effort: listener errors never propagate to caller
-    }
-  }
-
-  /** Subscribe to a typed event. Returns unsubscribe function. */
-  on<K extends TeamEventName>(event: K, listener: (data: TeamEventMap[K]) => void): () => void {
-    this.emitter.on(event, listener);
-    return () => { this.emitter.off(event, listener); };
-  }
-
-  /** Subscribe to a typed event, fire only once. */
-  once<K extends TeamEventName>(event: K, listener: (data: TeamEventMap[K]) => void): void {
-    this.emitter.once(event, listener);
-  }
-
-  /** Remove all listeners for a specific event, or all events if none specified. */
-  removeAllListeners(event?: TeamEventName): void {
-    if (event) {
-      this.emitter.removeAllListeners(event);
-    } else {
-      this.emitter.removeAllListeners();
-    }
-  }
-
-  /** Current listener count for a specific event. */
-  listenerCount(event: TeamEventName): number {
-    return this.emitter.listenerCount(event);
-  }
-}
+/**
+ * TeamEventBus — Process-local typed event emitter for team coordination.
+ *
+ * Phase 4b: Provides push-based acceleration within a single process.
+ * NOT a cross-process mechanism — the orchestrator uses SQLite polling.
+ *
+ * Architectural boundary (B1): This is process-local fanout only.
+ * No persistence, no cross-process delivery, no durability guarantees.
+ * If no listeners are registered, events are silently dropped.
+ */
+
+import { EventEmitter } from 'node:events';
+
+// ── Event type map ─────────────────────────────────────────────────
+
+export interface TeamEventMap {
+  'task:created':   { taskId: string; projectId: string; description: string };
+  'task:claimed':   { taskId: string; projectId: string; agentId: string };
+  'task:completed': { taskId: string; projectId: string; agentId: string; result?: string };
+  'task:failed':    { taskId: string; projectId: string; agentId: string; result?: string };
+  'task:released':  { taskId: string; projectId: string; agentId: string };
+  'agent:joined':   { agentId: string; projectId: string; agentType: string };
+  'agent:left':     { agentId: string; projectId: string };
+  'agent:stale':    { agentId: string; projectId: string; releasedTasks: number };
+  'handoff:created':{ observationId: number; projectId: string; fromAgent: string; toAgent?: string; taskId?: string };
+}
+
+export type TeamEventName = keyof TeamEventMap;
+
+// ── TeamEventBus ───────────────────────────────────────────────────
+
+export class TeamEventBus {
+  private emitter = new EventEmitter();
+
+  constructor() {
+    // Prevent memory leak warnings for legitimate multi-listener scenarios
+    this.emitter.setMaxListeners(50);
+  }
+
+  /**
+   * Emit a typed event. Non-blocking, best-effort.
+   * If no listeners are registered, the event is silently dropped.
+   */
+  emit<K extends TeamEventName>(event: K, data: TeamEventMap[K]): void {
+    try {
+      this.emitter.emit(event, data);
+    } catch {
+      // Best-effort: listener errors never propagate to caller
+    }
+  }
+
+  /** Subscribe to a typed event. Returns unsubscribe function. */
+  on<K extends TeamEventName>(event: K, listener: (data: TeamEventMap[K]) => void): () => void {
+    this.emitter.on(event, listener);
+    return () => { this.emitter.off(event, listener); };
+  }
+
+  /** Subscribe to a typed event, fire only once. */
+  once<K extends TeamEventName>(event: K, listener: (data: TeamEventMap[K]) => void): void {
+    this.emitter.once(event, listener);
+  }
+
+  /** Remove all listeners for a specific event, or all events if none specified. */
+  removeAllListeners(event?: TeamEventName): void {
+    if (event) {
+      this.emitter.removeAllListeners(event);
+    } else {
+      this.emitter.removeAllListeners();
+    }
+  }
+
+  /** Current listener count for a specific event. */
+  listenerCount(event: TeamEventName): number {
+    return this.emitter.listenerCount(event);
+  }
+}