ideaco 1.1.5

package/src/core/organization/group-chat-loop.js

@@ -0,0 +1,264 @@
+/**
+ * Group Chat Loop — Thin Global Coordinator
+ *
+ * This module is now a lightweight shell that:
+ *  - Holds the company reference and running state
+ *  - Registers / unregisters employees
+ *  - Delegates all per-employee behaviour to EmployeeLifecycle
+ *  - Emits events for the frontend (monologue:start, monologue:end, etc.)
+ *  - Provides aggregate queries (all active thinkers, etc.)
+ *  - Handles serialization/deserialization of all lifecycle states
+ *
+ * All the heavy logic (poll cycles, flow thinking, anti-spam, prompt building,
+ * fallback, self-check, idle-chat) now lives in employee/lifecycle.js.
+ */
+
+import EventEmitter from 'eventemitter3';
+
+/**
+ * GroupChatLoop — Global Chat Loop Coordinator
+ */
+export class GroupChatLoop extends EventEmitter {
+  constructor() {
+    super();
+    this.company = null;
+    this.running = false;
+
+    // agentId → EmployeeLifecycle (populated when employees join)
+    this._lifecycles = new Map();
+  }
+
+  // ========================================================================
+  // Lifecycle management
+  // ========================================================================
+
+  /**
+   * Start the coordinator.
+   * @param {object} company
+   */
+  start(company) {
+    if (this.running) return;
+    this.company = company;
+    this.running = true;
+    console.log('🔄 GroupChatLoop: Chat loop engine started');
+    this.emit('started');
+  }
+
+  /**
+   * Stop the coordinator and all employee lifecycles.
+   */
+  stop() {
+    this.running = false;
+    for (const [, lifecycle] of this._lifecycles) {
+      lifecycle.stop();
+    }
+    console.log('⏹️ GroupChatLoop: Chat loop engine stopped');
+    this.emit('stopped');
+  }
+
+  // ========================================================================
+  // Agent registration
+  // ========================================================================
+
+  /**
+   * Start the poll loop for an employee.
+   * The employee is expected to have a `.lifecycle` (EmployeeLifecycle) property.
+   */
+  startAgentLoop(agent) {
+    if (!this.running) return;
+    if (this._lifecycles.has(agent.id)) return; // already registered
+
+    const lifecycle = agent.lifecycle;
+    if (!lifecycle) {
+      console.warn(`  ⚠️ [GroupChatLoop] ${agent.name} has no lifecycle, skipping`);
+      return;
+    }
+
+    lifecycle.setCoordinator(this);
+
+    // Restore any pending state from persistence
+    if (this._pendingRestore?.has(agent.id)) {
+      lifecycle.restore(this._pendingRestore.get(agent.id));
+      this._pendingRestore.delete(agent.id);
+    }
+
+    lifecycle.start();
+    this._lifecycles.set(agent.id, lifecycle);
+
+    // NOTE: wakeUp() follows lazy-loading principle.
+    // Employees are NOT woken up here — they will be automatically
+    // woken up on their first chat() call via _ensureSession().
+    // This avoids unnecessary session initialization for idle employees.
+
+    console.log(`  🔄 [GroupChatLoop] ${agent.name} joined chat loop`);
+  }
+
+  /**
+   * Stop the poll loop for an employee.
+   */
+  stopAgentLoop(agentId) {
+    const lifecycle = this._lifecycles.get(agentId);
+    if (lifecycle) {
+      lifecycle.stop();
+      this._lifecycles.delete(agentId);
+    }
+  }
+
+  // ========================================================================
+  // Triggering
+  // ========================================================================
+
+  /**
+   * Trigger an employee to check a group (e.g. on @mention).
+   * The employee will be lazily woken up via _ensureSession() when they chat().
+   */
+  async triggerImmediate(agentId, groupId, _triggerMessage) {
+    if (!this.running || !this.company) return;
+    const lifecycle = this._lifecycles.get(agentId);
+    if (!lifecycle) return;
+    await lifecycle.triggerCheck(groupId);
+  }
+
+  /**
+   * Nudge an employee to check a group (lower urgency, used internally by lifecycles).
+   * The employee will be lazily woken up via _ensureSession() when they chat().
+   */
+  async nudgeAgent(agentId, groupId) {
+    if (!this.running || !this.company) return;
+    const lifecycle = this._lifecycles.get(agentId);
+    if (!lifecycle) {
+      // Agent might not have a lifecycle yet (e.g. hasn't joined loop)
+      // Try to find the employee and trigger directly
+      const agent = this._findAgent(agentId);
+      if (agent?.lifecycle) {
+        agent.lifecycle.setCoordinator(this);
+        await agent.lifecycle._processGroupMessages(groupId, false);
+      }
+      return;
+    }
+    // Use processGroupMessages directly (no mention flag)
+    await lifecycle._processGroupMessages(groupId, false).catch(() => {});
+  }
+
+  // ========================================================================
+  // Queries
+  // ========================================================================
+
+  /**
+   * Get an employee's active monologue for a group.
+   */
+  getActiveMonologue(agentId, groupId) {
+    const lifecycle = this._lifecycles.get(agentId);
+    return lifecycle?.getActiveMonologue(groupId) || null;
+  }
+
+  /**
+   * Get an employee's monologue history for a group.
+   */
+  getMonologueHistory(agentId, groupId, limit = 10) {
+    const lifecycle = this._lifecycles.get(agentId);
+    return lifecycle?.getMonologueHistory(groupId, limit) || [];
+  }
+
+  /**
+   * Get all employees currently in flow state across all groups.
+   */
+  getActiveThinkingAgents() {
+    const result = [];
+    for (const [, lifecycle] of this._lifecycles) {
+      result.push(...lifecycle.getActiveThinking());
+    }
+    return result;
+  }
+
+  // ========================================================================
+  // Serialization
+  // ========================================================================
+
+  /**
+   * Serialize all lifecycle states for persistence.
+   */
+  serialize() {
+    // Aggregate all lifecycle states keyed by agentId
+    // But we need backward-compatible format: flat maps keyed by `${agentId}:${groupId}`
+    const lastReadIndex = {};
+    const lastProcessedVisible = {};
+    const agentMemory = {};
+
+    for (const [agentId, lifecycle] of this._lifecycles) {
+      const state = lifecycle.serialize();
+      // Re-key from groupId to `${agentId}:${groupId}` for backward compat
+      for (const [groupId, val] of Object.entries(state.lastReadIndex)) {
+        lastReadIndex[`${agentId}:${groupId}`] = val;
+      }
+      for (const [groupId, val] of Object.entries(state.lastProcessedVisible)) {
+        lastProcessedVisible[`${agentId}:${groupId}`] = val;
+      }
+      for (const [groupId, val] of Object.entries(state.agentMemory)) {
+        agentMemory[`${agentId}:${groupId}`] = val;
+      }
+    }
+
+    return { lastReadIndex, lastProcessedVisible, agentMemory };
+  }
+
+  /**
+   * Restore lifecycle states from persistence data.
+   * Called after employees are loaded — distributes state to each lifecycle.
+   */
+  restore(data) {
+    if (!data) return;
+
+    // Parse the flat `${agentId}:${groupId}` keys back into per-agent maps
+    const perAgent = new Map(); // agentId → { lastReadIndex, lastProcessedVisible, agentMemory }
+
+    const distribute = (flatMap, field) => {
+      if (!flatMap) return;
+      for (const [compositeKey, val] of Object.entries(flatMap)) {
+        const sepIdx = compositeKey.indexOf(':');
+        if (sepIdx === -1) continue;
+        const agentId = compositeKey.slice(0, sepIdx);
+        const groupId = compositeKey.slice(sepIdx + 1);
+        if (!perAgent.has(agentId)) {
+          perAgent.set(agentId, { lastReadIndex: {}, lastProcessedVisible: {}, agentMemory: {} });
+        }
+        perAgent.get(agentId)[field][groupId] = val;
+      }
+    };
+
+    distribute(data.lastReadIndex, 'lastReadIndex');
+    distribute(data.lastProcessedVisible, 'lastProcessedVisible');
+    distribute(data.agentMemory, 'agentMemory');
+
+    // Now distribute to lifecycles that are already registered
+    for (const [agentId, agentData] of perAgent) {
+      const lifecycle = this._lifecycles.get(agentId);
+      if (lifecycle) {
+        lifecycle.restore(agentData);
+      } else {
+        // Store for later — when the agent joins, we'll restore then
+        if (!this._pendingRestore) this._pendingRestore = new Map();
+        this._pendingRestore.set(agentId, agentData);
+      }
+    }
+  }
+
+  // ========================================================================
+  // Internal helpers
+  // ========================================================================
+
+  /**
+   * Find an employee by ID across all departments.
+   */
+  _findAgent(agentId) {
+    if (!this.company) return null;
+    for (const dept of this.company.departments.values()) {
+      const agent = dept.agents.get(agentId);
+      if (agent) return agent;
+    }
+    return null;
+  }
+}
+
+// Global singleton
+export const groupChatLoop = new GroupChatLoop();

package/src/core/organization/index.js

@@ -0,0 +1,8 @@
+/**
+ * Organization Module - Company structure & governance
+ * Contains Company, Department, Team/Sprint management, HR
+ */
+export { Company } from './company.js';
+export { Department } from './department.js';
+export { TeamManager, Team, Sprint, SprintStatus } from './team.js';
+export { HRSystem, JobTemplates } from './workforce/hr.js';

package/src/core/organization/persistence.js

@@ -0,0 +1,111 @@
+/**
+ * Persistence Storage Module
+ * 
+ * Serializes Company's full state to disk (JSON), auto-restores after server restart.
+ * Storage location: under project root data/ directory.
+ */
+import fs from 'fs';
+import { saveAllAgentMemories, loadAgentMemory, clearAllMemories } from '../employee/memory/store.js';
+import { DATA_DIR, STATE_FILE, BACKUP_FILE, CHATS_DIR } from '../../lib/paths.js';
+
+// Ensure data directory exists
+if (!fs.existsSync(DATA_DIR)) {
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+}
+
+/**
+ * Save company state to disk
+ * @param {Company} company - Company instance
+ */
+export function saveState(company) {
+  if (!company) return;
+  try {
+    // Collect all Agent memories, save to separate files
+    const agentMemories = [];
+    company.departments.forEach(dept => {
+      dept.getMembers().forEach(agent => {
+        agentMemories.push({
+          agentId: agent.id,
+          memoryData: agent.memory.serialize(),
+          meta: { name: agent.name, role: agent.role, department: dept.name },
+        });
+      });
+    });
+    // Secretary's memory also saved separately
+    if (company.secretary) {
+      agentMemories.push({
+        agentId: company.secretary.id,
+        memoryData: company.secretary.memory.serialize(),
+        meta: { name: company.secretary.name, role: 'Personal Secretary', department: 'HQ' },
+      });
+    }
+    saveAllAgentMemories(agentMemories);
+
+    const serialized = company.serialize();
+    const json = JSON.stringify(serialized, null, 2);
+
+    // Backup old file first
+    if (fs.existsSync(STATE_FILE)) {
+      fs.copyFileSync(STATE_FILE, BACKUP_FILE);
+    }
+
+    // Write new state
+    fs.writeFileSync(STATE_FILE, json, 'utf-8');
+    console.log(`💾 State persisted (${(json.length / 1024).toFixed(1)}KB)`);
+  } catch (e) {
+    console.error('❌ Persistence failed:', e.message);
+  }
+}
+
+/**
+ * Load company state from disk
+ * @returns {object|null} Serialized state data, or null
+ */
+export function loadState() {
+  try {
+    let filePath = STATE_FILE;
+    if (!fs.existsSync(filePath)) {
+      filePath = BACKUP_FILE;
+      if (!fs.existsSync(filePath)) return null;
+    }
+
+    const json = fs.readFileSync(filePath, 'utf-8');
+    const data = JSON.parse(json);
+    console.log(`📂 State loaded from disk: ${data.name || 'unknown'}`);
+    return data;
+  } catch (e) {
+    console.error('❌ Failed to load state:', e.message);
+    return null;
+  }
+}
+
+/**
+ * Delete persisted data (reset)
+ */
+export function clearState() {
+  try {
+    if (fs.existsSync(STATE_FILE)) fs.unlinkSync(STATE_FILE);
+    if (fs.existsSync(BACKUP_FILE)) fs.unlinkSync(BACKUP_FILE);
+    clearAllMemories();
+    // Clear all chat files (including group chats stored in data/chats/)
+    if (fs.existsSync(CHATS_DIR)) {
+      fs.rmSync(CHATS_DIR, { recursive: true, force: true });
+      fs.mkdirSync(CHATS_DIR, { recursive: true });
+    }
+    console.log('🗑️ Persisted data cleared (including memory, chat files)');
+  } catch (e) {
+    console.error('❌ Clear failed:', e.message);
+  }
+}
+
+/**
+ * Debounced save: prevent frequent disk writes
+ */
+let saveTimer = null;
+export function debouncedSave(company, delay = 2000) {
+  if (saveTimer) clearTimeout(saveTimer);
+  saveTimer = setTimeout(() => {
+    saveState(company);
+    saveTimer = null;
+  }, delay);
+}

package/src/core/organization/team.js

@@ -0,0 +1,267 @@
+import { v4 as uuidv4 } from 'uuid';
+import { chatStore } from '../agent/chat-store.js';
+
+/**
+ * Sprint status enum
+ */
+export const SprintStatus = {
+  DRAFT: 'draft',             // Sprint draft, not started yet
+  DISCUSSING: 'discussing',   // Leader initiates group discussion on sprint plan
+  PENDING_APPROVAL: 'pending_approval', // Discussion complete, waiting for Boss approval
+  IN_PROGRESS: 'in_progress', // Boss approved, sprint in progress
+  COMPLETED: 'completed',     // Sprint completed
+  FAILED: 'failed',           // Sprint failed
+};
+
+/**
+ * Sprint — similar to a Requirement, one iteration cycle
+ */
+export class Sprint {
+  constructor({ title, goal, teamId, teamName }) {
+    this.id = uuidv4();
+    this.title = title;
+    this.goal = goal;                // Sprint goal
+    this.teamId = teamId;
+    this.teamName = teamName;
+    this.status = SprintStatus.DRAFT;
+    this.plan = null;                // Sprint plan formed after discussion
+    this.requirementId = null;       // Standard requirement ID created after approval
+    this.workflow = null;            // (deprecated) workflow is managed by the associated requirement
+    this.groupChat = [];             // Sprint group chat
+    this.outputs = [];               // Outputs
+    this.createdAt = new Date();
+    this.startedAt = null;
+    this.completedAt = null;
+    this.summary = null;
+
+    // Live progress
+    this.liveStatus = {
+      currentNodeId: null,
+      currentNodeTitle: null,
+      currentAgent: null,
+      currentAction: null,
+      lastActiveAt: null,
+      heartbeat: null,
+      toolCallsInProgress: [],
+      recentFileChanges: [],
+    };
+  }
+
+  updateLiveStatus(updates) {
+    Object.assign(this.liveStatus, updates, { lastActiveAt: new Date(), heartbeat: new Date() });
+  }
+
+  addFileChange(agentName, filePath, action = 'write') {
+    this.liveStatus.recentFileChanges.push({ agentName, filePath, action, time: new Date() });
+    if (this.liveStatus.recentFileChanges.length > 100) {
+      this.liveStatus.recentFileChanges = this.liveStatus.recentFileChanges.slice(-100);
+    }
+    this.liveStatus.lastActiveAt = new Date();
+    this.liveStatus.heartbeat = new Date();
+  }
+
+  addGroupMessage(from, content, type = 'message', visibility = null) {
+    const resolvedVisibility = visibility || (type === 'tool_call' || type === 'output' ? 'flow' : 'group');
+    const msg = {
+      id: uuidv4(),
+      from: {
+        id: from.id || 'system',
+        name: from.name || 'System',
+        avatar: from.avatar || null,
+        role: from.role || null,
+      },
+      content,
+      type,
+      visibility: resolvedVisibility,
+      time: new Date(),
+    };
+    this.groupChat.push(msg);
+    // Persist to file storage
+    try { chatStore.appendGroupMessage(`sprint-${this.id}`, msg); } catch {}
+    this.liveStatus.heartbeat = new Date();
+    this.liveStatus.lastActiveAt = new Date();
+  }
+
+  addOutput(agentId, agentName, role, outputType, content, metadata = {}) {
+    this.outputs.push({
+      id: uuidv4(), agentId, agentName, role, outputType, content, metadata, createdAt: new Date(),
+    });
+  }
+
+  serialize() {
+    return {
+      id: this.id,
+      title: this.title,
+      goal: this.goal,
+      teamId: this.teamId,
+      teamName: this.teamName,
+      status: this.status,
+      plan: this.plan,
+      requirementId: this.requirementId,
+      workflow: this.workflow,
+      // groupChat is persisted in chatStore files (data/chats/group-sprint-{id}/)
+      outputs: this.outputs,
+      createdAt: this.createdAt,
+      startedAt: this.startedAt,
+      completedAt: this.completedAt,
+      summary: this.summary,
+      liveStatus: this.liveStatus,
+    };
+  }
+
+  static deserialize(data) {
+    const s = new Sprint({
+      title: data.title,
+      goal: data.goal,
+      teamId: data.teamId,
+      teamName: data.teamName,
+    });
+    s.id = data.id;
+    s.status = data.status;
+    s.plan = data.plan;
+    s.requirementId = data.requirementId || null;
+    s.workflow = data.workflow;
+
+    // Load groupChat from file storage; migrate legacy inline data if present
+    const groupId = `sprint-${s.id}`;
+    if (data.groupChat && data.groupChat.length > 0) {
+      chatStore.migrateGroupChat(groupId, data.groupChat);
+    }
+    s.groupChat = chatStore.getGroupMessages(groupId, 500);
+
+    s.outputs = data.outputs || [];
+    s.createdAt = data.createdAt ? new Date(data.createdAt) : new Date();
+    s.startedAt = data.startedAt ? new Date(data.startedAt) : null;
+    s.completedAt = data.completedAt ? new Date(data.completedAt) : null;
+    s.summary = data.summary;
+    s.liveStatus = data.liveStatus || {
+      currentNodeId: null, currentNodeTitle: null, currentAgent: null,
+      currentAction: null, lastActiveAt: null, heartbeat: null,
+      toolCallsInProgress: [], recentFileChanges: [],
+    };
+    return s;
+  }
+}
+
+/**
+ * Team — a specialized subgroup within a department
+ */
+export class Team {
+  constructor({ name, departmentId, departmentName, memberIds, leaderId, leaderName, description }) {
+    this.id = uuidv4();
+    this.name = name;
+    this.departmentId = departmentId;
+    this.departmentName = departmentName;
+    this.memberIds = memberIds || [];      // Team member ID list
+    this.leaderId = leaderId;              // Leader ID
+    this.leaderName = leaderName;
+    this.description = description || '';
+    this.skills = [];                       // Team skill list
+    this.workspacePath = null;              // Dedicated workspace directory
+    this.sprints = new Map();              // Sprint list (sprintId => Sprint)
+    this.createdAt = new Date();
+    this.status = 'active';                // active | archived
+  }
+
+  addSprint(sprint) {
+    this.sprints.set(sprint.id, sprint);
+    return sprint;
+  }
+
+  getSprint(id) {
+    return this.sprints.get(id);
+  }
+
+  listSprints() {
+    return [...this.sprints.values()].sort(
+      (a, b) => new Date(b.createdAt) - new Date(a.createdAt)
+    );
+  }
+
+  serialize() {
+    return {
+      id: this.id,
+      name: this.name,
+      departmentId: this.departmentId,
+      departmentName: this.departmentName,
+      memberIds: this.memberIds,
+      leaderId: this.leaderId,
+      leaderName: this.leaderName,
+      description: this.description,
+      skills: this.skills,
+      workspacePath: this.workspacePath,
+      sprints: [...this.sprints.values()].map(s => s.serialize()),
+      createdAt: this.createdAt,
+      status: this.status,
+    };
+  }
+
+  static deserialize(data) {
+    const t = new Team({
+      name: data.name,
+      departmentId: data.departmentId,
+      departmentName: data.departmentName,
+      memberIds: data.memberIds,
+      leaderId: data.leaderId,
+      leaderName: data.leaderName,
+      description: data.description,
+    });
+    t.id = data.id;
+    t.skills = data.skills || [];
+    t.workspacePath = data.workspacePath || null;
+    t.createdAt = data.createdAt ? new Date(data.createdAt) : new Date();
+    t.status = data.status || 'active';
+    // Deserialize sprints
+    for (const sd of (data.sprints || [])) {
+      const sprint = Sprint.deserialize(sd);
+      t.sprints.set(sprint.id, sprint);
+    }
+    return t;
+  }
+}
+
+/**
+ * TeamManager — manages all teams
+ */
+export class TeamManager {
+  constructor() {
+    this.teams = new Map();
+  }
+
+  create(data) {
+    const team = new Team(data);
+    this.teams.set(team.id, team);
+    return team;
+  }
+
+  get(id) {
+    return this.teams.get(id);
+  }
+
+  delete(id) {
+    return this.teams.delete(id);
+  }
+
+  listAll() {
+    return [...this.teams.values()].sort(
+      (a, b) => new Date(b.createdAt) - new Date(a.createdAt)
+    );
+  }
+
+  listByDepartment(departmentId) {
+    return this.listAll().filter(t => t.departmentId === departmentId);
+  }
+
+  serialize() {
+    return [...this.teams.values()].map(t => t.serialize());
+  }
+
+  static deserialize(dataList) {
+    const mgr = new TeamManager();
+    for (const d of (dataList || [])) {
+      const team = Team.deserialize(d);
+      mgr.teams.set(team.id, team);
+    }
+    return mgr;
+  }
+}