memorix 1.4.5 → 1.5.0

package/src/orchestrate/context-compact.ts

@@ -1,188 +0,0 @@
-/**
- * Context Compaction — Phase 7, Step 6: 4-layer compaction for long pipelines.
- *
- * Prevents context overflow by progressively compacting older content:
- *   Layer 1: Tool Result Micro-Compact — trim old ledger entries to short placeholders
- *   Layer 2: Gate Output Compact — handled by output-budget.ts (trimAndPersist)
- *   Layer 3: Fix Prompt Compaction — summarize previous fix attempts
- *   Layer 4: Pipeline-Level Compaction — compact old tasks in long pipelines
- *
- * Circuit Breaker: if compaction fails, fall back to simple truncation
- * (first 500 + last 500 chars). Never let compaction crash the pipeline.
- */
-
-import { trimToBudget } from './output-budget.js';
-
-// ── Types ──────────────────────────────────────────────────────────
-
-export interface CompactionConfig {
-  /** Max number of full ledger entries to keep (older ones get compacted). Default: 5 */
-  maxFullEntries: number;
-  /** Max total chars for all fix attempt summaries. Default: 2000 */
-  fixHistoryBudget: number;
-  /** Pipeline task count threshold for pipeline-level compaction. Default: 20 */
-  pipelineCompactThreshold: number;
-  /** Number of recent tasks to keep in full detail during pipeline compaction. Default: 5 */
-  recentTaskWindow: number;
-}
-
-export const DEFAULT_COMPACTION_CONFIG: CompactionConfig = {
-  maxFullEntries: 5,
-  fixHistoryBudget: 2000,
-  pipelineCompactThreshold: 20,
-  recentTaskWindow: 5,
-};
-
-export interface LedgerEntry {
-  taskId: string;
-  role: string;
-  agent: string;
-  status: 'completed' | 'failed';
-  summary: string;
-  durationMs: number;
-}
-
-export interface FixAttemptRecord {
-  attempt: number;
-  gate: string;
-  errorOutput: string;
-  fixOutput: string;
-  passed: boolean;
-}
-
-// ── Layer 1: Tool Result Micro-Compact ─────────────────────────────
-
-/**
- * Compact old ledger entries: keep only the N most recent in full detail,
- * replace older ones with one-line placeholders.
- *
- * Never throws — returns input unchanged on error.
- */
-export function compactLedgerEntries(
-  entries: LedgerEntry[],
-  config: CompactionConfig = DEFAULT_COMPACTION_CONFIG,
-): string {
-  try {
-    if (entries.length <= config.maxFullEntries) {
-      return entries.map(formatFullEntry).join('\n');
-    }
-
-    const oldEntries = entries.slice(0, entries.length - config.maxFullEntries);
-    const recentEntries = entries.slice(-config.maxFullEntries);
-
-    const compactedOld = oldEntries.map(e => {
-      const status = e.status === 'completed' ? '[OK]' : '[ERROR]';
-      return `  ${status} ${e.role}/${e.agent}: ${e.summary.slice(0, 60)}`;
-    }).join('\n');
-
-    const compactedHeader = `### Earlier tasks (${oldEntries.length} compacted)\n${compactedOld}`;
-    const recentSection = `### Recent tasks (${recentEntries.length} full)\n${recentEntries.map(formatFullEntry).join('\n')}`;
-
-    return `${compactedHeader}\n\n${recentSection}`;
-  } catch {
-    // Circuit breaker: return raw entries on failure
-    return entries.map(formatFullEntry).join('\n');
-  }
-}
-
-// ── Layer 3: Fix Prompt Compaction ─────────────────────────────────
-
-/**
- * Compact fix attempt history for inclusion in the next fix prompt.
- * After the first attempt, summarize previous attempts instead of
- * including full error + fix outputs each time.
- *
- * Never throws — returns simple concatenation on error.
- */
-export function compactFixHistory(
-  attempts: FixAttemptRecord[],
-  config: CompactionConfig = DEFAULT_COMPACTION_CONFIG,
-): string {
-  try {
-    if (attempts.length === 0) return '';
-
-    // First attempt: no history needed
-    if (attempts.length === 1) {
-      return formatFixAttempt(attempts[0]);
-    }
-
-    // Multiple attempts: summarize older, keep latest full
-    const older = attempts.slice(0, -1);
-    const latest = attempts[attempts.length - 1];
-
-    const olderSummary = older.map((a, i) => {
-      const status = a.passed ? 'PASSED' : 'FAILED';
-      return `  - Attempt ${i + 1}: ${status} (${a.gate}) — ${a.errorOutput.slice(0, 80)}`;
-    }).join('\n');
-
-    let history = `### Previous fix attempts (${older.length} summarized)\n${olderSummary}`;
-
-    // Enforce budget on history section
-    if (history.length > config.fixHistoryBudget) {
-      history = trimToBudget(history, config.fixHistoryBudget);
-    }
-
-    return `${history}\n\n### Latest attempt\n${formatFixAttempt(latest)}`;
-  } catch {
-    // Circuit breaker: simple concatenation
-    return attempts.map(formatFixAttempt).join('\n---\n');
-  }
-}
-
-// ── Layer 4: Pipeline-Level Compaction ─────────────────────────────
-
-/**
- * Compact an entire pipeline's task list for prompt injection.
- * For long pipelines (>threshold tasks), compact older entries into
- * a summary paragraph, keeping only the recent N tasks in full.
- *
- * Never throws — returns full list on error.
- */
-export function compactPipelineContext(
-  entries: LedgerEntry[],
-  config: CompactionConfig = DEFAULT_COMPACTION_CONFIG,
-): string {
-  try {
-    if (entries.length <= config.pipelineCompactThreshold) {
-      return compactLedgerEntries(entries, config);
-    }
-
-    const oldEntries = entries.slice(0, entries.length - config.recentTaskWindow);
-    const recentEntries = entries.slice(-config.recentTaskWindow);
-
-    // Summary stats for old entries
-    const completedCount = oldEntries.filter(e => e.status === 'completed').length;
-    const failedCount = oldEntries.filter(e => e.status === 'failed').length;
-    const roles = [...new Set(oldEntries.map(e => e.role))];
-
-    const summary = [
-      `### Pipeline progress (${entries.length} total tasks)`,
-      `${oldEntries.length} earlier tasks: ${completedCount} completed, ${failedCount} failed.`,
-      `Roles involved: ${roles.join(', ')}.`,
-    ].join('\n');
-
-    const recentSection = `### Recent tasks (${recentEntries.length} full detail)\n${recentEntries.map(formatFullEntry).join('\n')}`;
-
-    return `${summary}\n\n${recentSection}`;
-  } catch {
-    // Circuit breaker: return full list via basic compaction
-    return compactLedgerEntries(entries, config);
-  }
-}
-
-// ── Helpers ────────────────────────────────────────────────────────
-
-function formatFullEntry(e: LedgerEntry): string {
-  const status = e.status === 'completed' ? '[OK]' : '[ERROR]';
-  const duration = `${(e.durationMs / 1000).toFixed(1)}s`;
-  return `- [${status}] **${e.role}** (${e.agent}, ${duration}): ${e.summary}`;
-}
-
-function formatFixAttempt(a: FixAttemptRecord): string {
-  const status = a.passed ? 'PASSED' : 'FAILED';
-  return [
-    `**Attempt ${a.attempt}** [${status}] — ${a.gate} gate`,
-    `Error: ${a.errorOutput.slice(0, 300)}`,
-    `Fix: ${a.fixOutput.slice(0, 300)}`,
-  ].join('\n');
-}

package/src/team/file-locks.ts

@@ -1,173 +0,0 @@
-/**
- * File Lock Registry — Advisory file locks for multi-agent coordination
- *
- * Prevents conflicting edits when multiple agents work on the same project.
- * Locks are advisory (not enforced at OS level) with TTL auto-release.
- * Default TTL: 10 minutes. Agents see lock status via session_start injection.
- */
-
-// ─── Types ───────────────────────────────────────────────────────────
-
-export interface LockResult {
-  success: boolean;
-  lockedBy: string;
-  file: string;
-}
-
-export interface LockInfo {
-  file: string;
-  lockedBy: string;
-  lockedAt: Date;
-  expiresAt: Date;
-}
-
-export interface LockOptions {
-  ttlMs?: number;
-}
-
-const DEFAULT_TTL_MS = 10 * 60 * 1000; // 10 minutes
-
-// ─── Internal Lock Entry ─────────────────────────────────────────────
-
-interface LockEntry {
-  file: string;
-  lockedBy: string;
-  lockedAt: Date;
-  expiresAt: Date;
-}
-
-// ─── Registry ────────────────────────────────────────────────────────
-
-export class FileLockRegistry {
-  private locks = new Map<string, LockEntry>();
-
-  /**
-   * Attempt to lock a file for an agent.
-   * Returns success:true if lock acquired, or success:false with current owner.
-   * Same agent re-locking is idempotent (refreshes TTL).
-   */
-  lock(file: string, agentId: string, options?: LockOptions): LockResult {
-    const ttl = options?.ttlMs ?? DEFAULT_TTL_MS;
-
-    // Clean expired locks first
-    this.cleanExpiredEntry(file);
-
-    const existing = this.locks.get(file);
-
-    if (existing) {
-      if (existing.lockedBy === agentId) {
-        // Same agent — refresh TTL
-        existing.expiresAt = new Date(Date.now() + ttl);
-        return { success: true, lockedBy: agentId, file };
-      }
-      // Different agent holds the lock
-      return { success: false, lockedBy: existing.lockedBy, file };
-    }
-
-    // No lock — acquire
-    const now = new Date();
-    this.locks.set(file, {
-      file,
-      lockedBy: agentId,
-      lockedAt: now,
-      expiresAt: new Date(now.getTime() + ttl),
-    });
-
-    return { success: true, lockedBy: agentId, file };
-  }
-
-  /**
-   * Release a lock. Only the owner can release.
-   * Returns true if released, false if not found or not owner.
-   */
-  unlock(file: string, agentId: string): boolean {
-    const entry = this.locks.get(file);
-    if (!entry) return false;
-    if (entry.lockedBy !== agentId) return false;
-
-    this.locks.delete(file);
-    return true;
-  }
-
-  /**
-   * Get lock status for a specific file. Returns null if unlocked.
-   */
-  getStatus(file: string): LockInfo | null {
-    this.cleanExpiredEntry(file);
-    const entry = this.locks.get(file);
-    if (!entry) return null;
-    return { ...entry };
-  }
-
-  /**
-   * List all active locks, optionally filtered by agent.
-   */
-  listLocks(agentId?: string): LockInfo[] {
-    this.cleanExpired();
-    const all = [...this.locks.values()];
-    const filtered = agentId ? all.filter(l => l.lockedBy === agentId) : all;
-    return filtered.map(l => ({ ...l }));
-  }
-
-  /**
-   * Release all locks held by a specific agent. Returns count released.
-   */
-  releaseAll(agentId: string): number {
-    let count = 0;
-    for (const [file, entry] of this.locks) {
-      if (entry.lockedBy === agentId) {
-        this.locks.delete(file);
-        count++;
-      }
-    }
-    return count;
-  }
-
-  /**
-   * Remove all expired locks.
-   */
-  cleanExpired(): void {
-    const now = Date.now();
-    for (const [file, entry] of this.locks) {
-      if (entry.expiresAt.getTime() <= now) {
-        this.locks.delete(file);
-      }
-    }
-  }
-
-  /**
-   * Check and remove a single expired lock entry.
-   */
-  private cleanExpiredEntry(file: string): void {
-    const entry = this.locks.get(file);
-    if (entry && entry.expiresAt.getTime() <= Date.now()) {
-      this.locks.delete(file);
-    }
-  }
-
-  /** Serialize state for file persistence */
-  serialize(): { locks: Record<string, unknown> } {
-    const locks: Record<string, unknown> = {};
-    for (const [file, entry] of this.locks) {
-      locks[file] = {
-        ...entry,
-        lockedAt: entry.lockedAt.toISOString(),
-        expiresAt: entry.expiresAt.toISOString(),
-      };
-    }
-    return { locks };
-  }
-
-  /** Hydrate state from file persistence */
-  hydrate(data: { locks?: Record<string, any> }): void {
-    this.locks.clear();
-    if (!data?.locks) return;
-    for (const [file, raw] of Object.entries(data.locks)) {
-      this.locks.set(file, {
-        ...(raw as any),
-        lockedAt: new Date((raw as any).lockedAt),
-        expiresAt: new Date((raw as any).expiresAt),
-      });
-    }
-  }
-}

package/src/team/index.ts

@@ -1,23 +0,0 @@
-/**
- * Team Module - Autonomous Multi-Agent Coordination
- *
- * Provides agent registry, message bus, file locks, and task management
- * for coordinating multiple AI agents working on the same project.
- *
- * Usage via HTTP transport:
- *   memorix serve-http --port 3211
- *
- * All team state is in-memory and shared across MCP sessions on the same server.
- */
-
-export { AgentRegistry } from './registry.js';
-export type { AgentInfo, AgentJoinInput, AgentListFilter } from './registry.js';
-
-export { MessageBus } from './messages.js';
-export type { Message, MessageType, MessageSendInput, MessageBroadcastInput } from './messages.js';
-
-export { FileLockRegistry } from './file-locks.js';
-export type { LockResult, LockInfo, LockOptions } from './file-locks.js';
-
-export { TaskManager } from './tasks.js';
-export type { Task, TaskStatus, TaskCreateInput, TaskListFilter } from './tasks.js';

package/src/team/messages.ts

@@ -1,203 +0,0 @@
-/**
- * Message Bus — Agent-to-agent communication
- *
- * In-memory message queue for team coordination.
- * Messages are temporary (not persisted as observations).
- * Supports direct send, broadcast, inbox retrieval, and read tracking.
- */
-
-import { randomUUID } from 'node:crypto';
-import type { AgentRegistry } from './registry.js';
-
-// ─── Types ───────────────────────────────────────────────────────────
-
-export type MessageType = 'request' | 'response' | 'info' | 'announcement' | 'contract' | 'error';
-
-export interface MessageSendInput {
-  from: string;
-  to: string;
-  type: MessageType;
-  content: string;
-}
-
-export interface MessageBroadcastInput {
-  from: string;
-  type: MessageType;
-  content: string;
-}
-
-export interface Message {
-  id: string;
-  from: string;
-  to: string;
-  type: MessageType;
-  content: string;
-  timestamp: Date;
-  read: boolean;
-}
-
-// ─── Message Bus ─────────────────────────────────────────────────────
-
-/** Max messages per inbox. Oldest read messages are evicted first. */
-const MAX_INBOX_SIZE = 200;
-/** Max message content length in bytes */
-const MAX_CONTENT_LENGTH = 10_000;
-
-export class MessageBus {
-  private inboxes = new Map<string, Message[]>();
-  private registry: AgentRegistry;
-
-  constructor(registry: AgentRegistry) {
-    this.registry = registry;
-  }
-
-  /**
-   * Send a message to a specific agent.
-   * Throws if receiver is unknown.
-   */
-  send(input: MessageSendInput): Message {
-    const receiver = this.registry.getAgent(input.to);
-    if (!receiver) {
-      throw new Error(`Unknown receiver agent: ${input.to}`);
-    }
-    if (receiver.status !== 'active') {
-      throw new Error(`Receiver agent is inactive: ${receiver.name}`);
-    }
-
-    const msg: Message = {
-      id: randomUUID(),
-      from: input.from,
-      to: input.to,
-      type: input.type,
-      content: input.content,
-      timestamp: new Date(),
-      read: false,
-    };
-
-    const inbox = this.inboxes.get(input.to) ?? [];
-    inbox.push(msg);
-
-    // Evict oldest read messages if inbox exceeds limit
-    if (inbox.length > MAX_INBOX_SIZE) {
-      const readIndices: number[] = [];
-      for (let i = 0; i < inbox.length; i++) {
-        if (inbox[i].read) readIndices.push(i);
-      }
-      // Remove oldest read messages first
-      const toRemove = inbox.length - MAX_INBOX_SIZE;
-      for (let i = Math.min(toRemove, readIndices.length) - 1; i >= 0; i--) {
-        inbox.splice(readIndices[i], 1);
-      }
-      // If still over limit, remove oldest unread
-      while (inbox.length > MAX_INBOX_SIZE) {
-        inbox.shift();
-      }
-    }
-
-    this.inboxes.set(input.to, inbox);
-    return msg;
-  }
-
-  /**
-   * Broadcast a message to all active agents except the sender.
-   */
-  broadcast(input: MessageBroadcastInput): Message[] {
-    const activeAgents = this.registry.listAgents({ status: 'active' });
-    const messages: Message[] = [];
-
-    for (const agent of activeAgents) {
-      if (agent.id === input.from) continue;
-
-      const msg = this.send({
-        from: input.from,
-        to: agent.id,
-        type: input.type,
-        content: input.content,
-      });
-      messages.push(msg);
-    }
-
-    return messages;
-  }
-
-  /**
-   * Get all messages in an agent's inbox (both read and unread).
-   */
-  getInbox(agentId: string): Message[] {
-    return [...(this.inboxes.get(agentId) ?? [])];
-  }
-
-  /**
-   * Mark specific messages as read.
-   */
-  markRead(agentId: string, messageIds: string[]): number {
-    const inbox = this.inboxes.get(agentId);
-    if (!inbox) return 0;
-
-    const idSet = new Set(messageIds);
-    let count = 0;
-    for (const msg of inbox) {
-      if (idSet.has(msg.id) && !msg.read) {
-        msg.read = true;
-        count++;
-      }
-    }
-    return count;
-  }
-
-  /**
-   * Count unread messages for an agent.
-   */
-  getUnreadCount(agentId: string): number {
-    const inbox = this.inboxes.get(agentId);
-    if (!inbox) return 0;
-    return inbox.filter(m => !m.read).length;
-  }
-
-  /**
-   * Remove all read messages from an agent's inbox.
-   * Returns the number of messages pruned.
-   */
-  pruneRead(agentId: string): number {
-    const inbox = this.inboxes.get(agentId);
-    if (!inbox) return 0;
-    const before = inbox.length;
-    const unread = inbox.filter(m => !m.read);
-    this.inboxes.set(agentId, unread);
-    return before - unread.length;
-  }
-
-  /**
-   * Clear all messages for an agent (used on agent leave).
-   */
-  clearInbox(agentId: string): void {
-    this.inboxes.delete(agentId);
-  }
-
-  /** Max allowed content length */
-  static get MAX_CONTENT_LENGTH() { return MAX_CONTENT_LENGTH; }
-
-  /** Serialize state for file persistence */
-  serialize(): { inboxes: Record<string, unknown[]> } {
-    const inboxes: Record<string, unknown[]> = {};
-    for (const [agentId, msgs] of this.inboxes) {
-      inboxes[agentId] = msgs.map(m => ({
-        ...m,
-        timestamp: m.timestamp.toISOString(),
-      }));
-    }
-    return { inboxes };
-  }
-
-  /** Hydrate state from file persistence */
-  hydrate(data: { inboxes?: Record<string, any[]> }): void {
-    this.inboxes.clear();
-    if (!data?.inboxes) return;
-    for (const [agentId, msgs] of Object.entries(data.inboxes)) {
-      this.inboxes.set(agentId, msgs.map(m => ({
-        ...m,
-        timestamp: new Date(m.timestamp),
-      })));
-    }
-  }
-}

package/src/team/persistence.ts

@@ -1,96 +0,0 @@
-/**
- * Team State Persistence - File-based shared state for orchestration coordination
- *
- * In stdio mode, each IDE spawns its own MCP process with isolated in-memory team state.
- * This persistence layer writes team state to a shared JSON file so all MCP processes
- * (Windsurf, Cursor, Claude Code, Antigravity, etc.) see the same agents, messages,
- * locks, and tasks.
- *
- * sync() — reload from disk if file changed (mtime check)
- * flush() — atomic write to disk (write tmp + rename)
- */
-
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { statSync, renameSync, existsSync } from 'node:fs';
-import { dirname } from 'node:path';
-import type { AgentRegistry } from './registry.js';
-import type { MessageBus } from './messages.js';
-import type { TaskManager } from './tasks.js';
-import type { FileLockRegistry } from './file-locks.js';
-
-// ─── Types ───────────────────────────────────────────────────────────
-
-interface TeamStateSnapshot {
-  version: 1;
-  updatedAt: string;
-  registry: ReturnType<AgentRegistry['serialize']>;
-  messages: ReturnType<MessageBus['serialize']>;
-  tasks: ReturnType<TaskManager['serialize']>;
-  locks: ReturnType<FileLockRegistry['serialize']>;
-}
-
-// ─── Persistence ─────────────────────────────────────────────────────
-
-export class TeamPersistence {
-  private lastMtimeMs = 0;
-
-  constructor(
-    private filePath: string,
-    private registry: AgentRegistry,
-    private messageBus: MessageBus,
-    private taskManager: TaskManager,
-    private fileLocks: FileLockRegistry,
-  ) {}
-
-  /** Reload state from disk if the file changed since last read */
-  async sync(): Promise<void> {
-    try {
-      if (!existsSync(this.filePath)) return;
-      const st = statSync(this.filePath);
-      if (st.mtimeMs <= this.lastMtimeMs) return;
-    } catch {
-      return;
-    }
-
-    try {
-      const raw = await readFile(this.filePath, 'utf8');
-      const snap: TeamStateSnapshot = JSON.parse(raw);
-      if (snap.version !== 1) return;
-
-      this.registry.hydrate(snap.registry);
-      this.messageBus.hydrate(snap.messages);
-      this.taskManager.hydrate(snap.tasks);
-      this.fileLocks.hydrate(snap.locks);
-
-      try { this.lastMtimeMs = statSync(this.filePath).mtimeMs; } catch { /* */ }
-    } catch {
-      // Corrupted or partial write — ignore, will be overwritten on next flush
-    }
-  }
-
-  /** Write current state to disk atomically (tmp + rename) */
-  async flush(): Promise<void> {
-    const snap: TeamStateSnapshot = {
-      version: 1,
-      updatedAt: new Date().toISOString(),
-      registry: this.registry.serialize(),
-      messages: this.messageBus.serialize(),
-      tasks: this.taskManager.serialize(),
-      locks: this.fileLocks.serialize(),
-    };
-
-    await mkdir(dirname(this.filePath), { recursive: true });
-    const tmp = this.filePath + '.' + process.pid + '.tmp';
-    await writeFile(tmp, JSON.stringify(snap, null, 2), 'utf8');
-
-    try {
-      renameSync(tmp, this.filePath);
-    } catch {
-      // Fallback: direct write if rename fails (cross-device)
-      await writeFile(this.filePath, JSON.stringify(snap, null, 2), 'utf8');
-      try { const { unlinkSync } = await import('node:fs'); unlinkSync(tmp); } catch { /* */ }
-    }
-
-    try { this.lastMtimeMs = statSync(this.filePath).mtimeMs; } catch { /* */ }
-  }
-}