Chapter 11: Virtual Office

┌─────────────────────────────────────────────────────────────────────────┐
│                           Human Manager                                  │
│                   (adds tasks, approves, reviews, intervenes)            │
└─────────────────────────────────┬───────────────────────────────────────┘
                                  │
┌─────────────────────────────────▼───────────────────────────────────────┐
│                           Coordinator                                    │
│              (classifies, routes, monitors, escalates)                   │
└──────┬─────────────────────────┬────────────────────────┬───────────────┘
       │                         │                        │
┌──────▼──────┐          ┌───────▼──────┐         ┌──────▼──────┐
│   Code      │          │   Research   │         │   Writing   │
│   Worker    │          │   Worker     │         │   Worker    │
│             │          │              │         │             │
│  (writes,   │          │  (searches,  │         │  (drafts,   │
│   tests,    │          │   analyzes,  │         │   edits,    │
│   debugs)   │          │   synthesizes)│        │   polishes) │
└──────┬──────┘          └───────┬──────┘         └──────┬──────┘
       │                         │                        │
       └─────────────────────────┼────────────────────────┘
                                 │
                    ┌────────────▼────────────┐
                    │       Task Board        │
                    │       (artifact)        │
                    │                         │
                    │  Backlog → In Progress  │
                    │     → Review → Done     │
                    └─────────────────────────┘

// types.ts
interface Task {
  id: string;
  title: string;
  description: string;
  type: 'code' | 'research' | 'writing' | 'general';
  priority: 'high' | 'medium' | 'low';
  status: 'backlog' | 'in-progress' | 'review' | 'done' | 'blocked';
  assignedTo: string | null;
  createdAt: number;
  startedAt: number | null;
  completedAt: number | null;
  result: string | null;
  feedback: string | null;
  attempts: number;
  metadata: Record<string, any>;
}

interface TaskBoard {
  tasks: Task[];
  history: TaskEvent[];
}

interface TaskEvent {
  timestamp: number;
  taskId: string;
  event: 'created' | 'assigned' | 'started' | 'completed' | 'blocked' | 'reviewed' | 'feedback';
  actor: string;
  details: string;
}

// taskboard.ts
export default class TaskBoardSystem extends AgenticSystem {
  @field board: TaskBoard = { tasks: [], history: [] };

  // ===== Task Lifecycle Operations =====

  @action()
  addTask(task: Omit<Task, 'id' | 'createdAt' | 'attempts' | 'status'>): string {
    const id = crypto.randomUUID();
    const newTask: Task = {
      ...task,
      id,
      status: 'backlog',
      createdAt: Date.now(),
      startedAt: null,
      completedAt: null,
      result: null,
      feedback: null,
      attempts: 0
    };

    this.board.tasks.push(newTask);
    this.recordEvent(id, 'created', 'manager', task.title);

    return id;
  }

  assignTask(taskId: string, workerId: string): boolean {
    const task = this.getTask(taskId);
    if (!task || task.status !== 'backlog') {
      return false; // Can only assign from backlog
    }

    task.assignedTo = workerId;
    task.status = 'in-progress';
    task.startedAt = Date.now();
    task.attempts += 1;

    this.recordEvent(taskId, 'assigned', 'coordinator', `Assigned to ${workerId}`);
    return true;
  }

  completeTask(taskId: string, result: string): boolean {
    const task = this.getTask(taskId);
    if (!task || task.status !== 'in-progress') {
      return false; // Can only complete in-progress tasks
    }

    task.status = 'review';
    task.result = result;
    task.completedAt = Date.now();

    this.recordEvent(taskId, 'completed', task.assignedTo || 'unknown', 'Task completed');
    return true;
  }

  blockTask(taskId: string, reason: string): boolean {
    const task = this.getTask(taskId);
    if (!task || task.status !== 'in-progress') {
      return false;
    }

    task.status = 'blocked';
    task.metadata.blockReason = reason;

    this.recordEvent(taskId, 'blocked', task.assignedTo || 'unknown', reason);
    return true;
  }

  @action()
  approveTask(taskId: string): boolean {
    const task = this.getTask(taskId);
    if (!task || task.status !== 'review') {
      return false;
    }

    task.status = 'done';
    this.recordEvent(taskId, 'reviewed', 'manager', 'Approved');
    return true;
  }

  @action()
  rejectTask(taskId: string, feedback: string): boolean {
    const task = this.getTask(taskId);
    if (!task || task.status !== 'review') {
      return false;
    }

    task.status = 'backlog'; // Back to backlog for retry
    task.feedback = feedback;
    task.assignedTo = null;

    this.recordEvent(taskId, 'feedback', 'manager', feedback);
    return true;
  }

  // ===== Query Operations =====

  getBacklogTasks(): Task[] {
    return this.board.tasks
      .filter(t => t.status === 'backlog')
      .sort((a, b) => {
        // Priority order: high > medium > low
        const priorityOrder = { high: 0, medium: 1, low: 2 };
        return priorityOrder[a.priority] - priorityOrder[b.priority];
      });
  }

  getTasksForWorker(workerId: string): Task[] {
    return this.board.tasks.filter(
      t => t.assignedTo === workerId && t.status === 'in-progress'
    );
  }

  getBlockedTasks(): Task[] {
    return this.board.tasks.filter(t => t.status === 'blocked');
  }

  getTasksInReview(): Task[] {
    return this.board.tasks.filter(t => t.status === 'review');
  }

  getCompletedTasks(since: number): Task[] {
    return this.board.tasks.filter(
      t => t.status === 'done' && t.completedAt && t.completedAt > since
    );
  }

  // ===== Helpers =====

  private getTask(id: string): Task | undefined {
    return this.board.tasks.find(t => t.id === id);
  }

  private recordEvent(taskId: string, event: TaskEvent['event'], actor: string, details: string) {
    this.board.history.push({
      timestamp: Date.now(),
      taskId,
      event,
      actor,
      details
    });
  }
}

// coordinator.ts
export default class Coordinator extends AgenticSystem {
  @field taskBoard: TaskBoardSystem;
  @field workers: Map<string, WorkerInfo> = new Map();
  @field status: stream<string>('');
  @field pendingEscalation: Escalation | null = null;

  // ===== Worker Management =====

  registerWorker(id: string, info: WorkerInfo) {
    this.workers.set(id, info);
    this.status.append(`Registered worker: ${id} (${info.specialties.join(', ')})\n`);
  }

  // ===== Core Coordination Loop =====

  @schedule('every 5 minutes')
  async coordinationCycle() {
    this.status.append(`\n--- Coordination Cycle ${new Date().toISOString()} ---\n`);

    // 1. Check for blocked tasks that need escalation
    await this.handleBlockedTasks();

    // 2. Check for tasks that have been in-progress too long
    await this.checkStuckTasks();

    // 3. Assign backlog tasks to available workers
    await this.assignBacklogTasks();

    // 4. Log cycle metrics
    this.logCycleMetrics();
  }

  async handleBlockedTasks() {
    const blocked = this.taskBoard.getBlockedTasks();

    for (const task of blocked) {
      this.status.append(`Handling blocked task: ${task.title}\n`);

      // Try to unblock with different worker
      if (task.attempts < 3) {
        const alternateWorker = this.findAlternateWorker(task);
        if (alternateWorker) {
          task.status = 'backlog';
          task.metadata.previouslyBlockedBy = task.assignedTo;
          task.assignedTo = null;
          this.status.append(`  Re-queuing for alternate worker\n`);
          continue;
        }
      }

      // Escalate to human
      this.status.append(`  Escalating to manager\n`);
      await this.escalateToHuman(task, task.metadata.blockReason);
    }
  }

  async checkStuckTasks() {
    const inProgress = this.taskBoard.board.tasks.filter(t => t.status === 'in-progress');
    const now = Date.now();
    const stuckThreshold = 30 * 60 * 1000; // 30 minutes

    for (const task of inProgress) {
      if (task.startedAt && now - task.startedAt > stuckThreshold) {
        this.status.append(`Task stuck: ${task.title} (${Math.round((now - task.startedAt) / 60000)}min)\n`);

        // Ping the worker first
        const worker = this.workers.get(task.assignedTo || '');
        if (worker) {
          // In a real system, this would check worker status
          this.status.append(`  Checking worker ${task.assignedTo} status\n`);
        }

        // If still stuck after 1 hour, escalate
        if (now - task.startedAt > 60 * 60 * 1000) {
          await this.escalateToHuman(task, 'Task exceeded time limit');
        }
      }
    }
  }

  async assignBacklogTasks() {
    const backlog = this.taskBoard.getBacklogTasks();

    for (const task of backlog) {
      const worker = this.selectWorker(task);

      if (worker) {
        const assigned = this.taskBoard.assignTask(task.id, worker.id);
        if (assigned) {
          this.status.append(`Assigned "${task.title}" to ${worker.id}\n`);
          await this.notifyWorker(worker.id, task);
        }
      } else {
        this.status.append(`No available worker for "${task.title}" (type: ${task.type})\n`);
      }
    }
  }

  // ===== Worker Selection (Routing) =====

  selectWorker(task: Task): WorkerInfo | null {
    // Find workers that can handle this task type
    const capable = Array.from(this.workers.values())
      .filter(w => w.specialties.includes(task.type) || w.specialties.includes('general'));

    if (capable.length === 0) return null;

    // Find available workers (not overloaded)
    const available = capable.filter(w => {
      const currentTasks = this.taskBoard.getTasksForWorker(w.id);
      return currentTasks.length < w.maxConcurrent;
    });

    if (available.length === 0) return null;

    // Prefer specialist over generalist
    const specialists = available.filter(w => w.specialties.includes(task.type));
    const candidates = specialists.length > 0 ? specialists : available;

    // If task has feedback from previous attempt, prefer different worker
    if (task.metadata.previouslyBlockedBy) {
      const different = candidates.filter(w => w.id !== task.metadata.previouslyBlockedBy);
      if (different.length > 0) {
        return different[0];
      }
    }

    // Return worker with best performance on this task type
    return this.selectByPerformance(candidates, task.type);
  }

  selectByPerformance(workers: WorkerInfo[], taskType: string): WorkerInfo {
    // Simple: return worker with highest success rate for this task type
    return workers.reduce((best, current) => {
      const bestRate = best.metrics[taskType]?.successRate || 0.5;
      const currentRate = current.metrics[taskType]?.successRate || 0.5;
      return currentRate > bestRate ? current : best;
    });
  }

  // ===== Human Integration =====

  async escalateToHuman(task: Task, reason: string) {
    this.pendingEscalation = {
      taskId: task.id,
      task,
      reason,
      timestamp: Date.now(),
      options: ['reassign', 'modify', 'cancel']
    };

    this.status.append(`ESCALATION: ${task.title}\n  Reason: ${reason}\n  Awaiting manager decision\n`);
  }

  @action()
  async handleEscalation(decision: 'reassign' | 'modify' | 'cancel', details?: string) {
    if (!this.pendingEscalation) return;

    const task = this.taskBoard.board.tasks.find(t => t.id === this.pendingEscalation!.taskId);
    if (!task) return;

    switch (decision) {
      case 'reassign':
        task.status = 'backlog';
        task.assignedTo = null;
        task.attempts = 0; // Reset attempts
        this.status.append(`Manager: Reassigning "${task.title}"\n`);
        break;

      case 'modify':
        task.status = 'backlog';
        task.assignedTo = null;
        if (details) {
          task.description = details;
        }
        this.status.append(`Manager: Modified and re-queued "${task.title}"\n`);
        break;

      case 'cancel':
        task.status = 'done';
        task.result = 'Cancelled by manager';
        task.metadata.cancelled = true;
        this.status.append(`Manager: Cancelled "${task.title}"\n`);
        break;
    }

    this.pendingEscalation = null;
  }

  // ===== Metrics =====

  logCycleMetrics() {
    const tasks = this.taskBoard.board.tasks;
    const metrics = {
      total: tasks.length,
      backlog: tasks.filter(t => t.status === 'backlog').length,
      inProgress: tasks.filter(t => t.status === 'in-progress').length,
      review: tasks.filter(t => t.status === 'review').length,
      done: tasks.filter(t => t.status === 'done').length,
      blocked: tasks.filter(t => t.status === 'blocked').length
    };

    this.status.append(`Metrics: ${JSON.stringify(metrics)}\n`);
  }

  async notifyWorker(workerId: string, task: Task) {
    // In a real system, this would trigger the worker to start
    // For now, we rely on workers checking their assigned tasks
  }

  private findAlternateWorker(task: Task): WorkerInfo | null {
    const capable = Array.from(this.workers.values())
      .filter(w => w.specialties.includes(task.type) || w.specialties.includes('general'));

    const alternatives = capable.filter(w => w.id !== task.assignedTo);
    return alternatives[0] || null;
  }
}

interface WorkerInfo {
  id: string;
  specialties: string[];
  maxConcurrent: number;
  metrics: Record<string, { successRate: number; avgDuration: number }>;
}

interface Escalation {
  taskId: string;
  task: Task;
  reason: string;
  timestamp: number;
  options: string[];
}

// code-worker.ts
export default class CodeWorker extends AgenticSystem {
  @field workerId = 'code-worker-1';
  @field currentTask: Task | null = null;
  @field thinking: stream<string>('');
  @field taskBoard: TaskBoardSystem;

  systemPrompt = `You are an expert software developer.
    You write clean, well-tested code.
    When given a coding task:
    1. Understand the requirements
    2. Plan your implementation
    3. Write the code
    4. Verify it works
    5. Report your result

    If you encounter blockers you cannot resolve, report them clearly.`;

  @schedule('every 2 minutes')
  async workCycle() {
    // Check for assigned tasks
    const tasks = this.taskBoard.getTasksForWorker(this.workerId);
    if (tasks.length === 0) return;

    // Work on first task
    this.currentTask = tasks[0];
    await this.executeTask(this.currentTask);
  }

  async executeTask(task: Task) {
    this.thinking.append(`Starting task: ${task.title}\n`);

    try {
      // Plan the implementation
      const plan = await this.planImplementation(task);
      this.thinking.append(`Plan:\n${plan}\n`);

      // Execute with feedback loop
      const result = await this.implementWithFeedback(task, plan);

      // Complete the task
      this.taskBoard.completeTask(task.id, result);
      this.thinking.append(`Task completed successfully\n`);

    } catch (error: any) {
      this.thinking.append(`Error: ${error.message}\n`);
      this.taskBoard.blockTask(task.id, error.message);
    }

    this.currentTask = null;
  }

  async planImplementation(task: Task): Promise<string> {
    const context = this.buildContext(task);

    const response = await llm.complete([
      { role: 'system', content: this.systemPrompt },
      { role: 'user', content: `Plan the implementation for this task:

        Title: ${task.title}
        Description: ${task.description}

        ${task.feedback ? `Previous attempt feedback: ${task.feedback}` : ''}

        Context:
        ${context}

        Create a step-by-step plan. Be specific about what code needs to be written.` }
    ]);

    // Assume llm.complete returns a string; if it returns an object, use response.text instead
    return typeof response === 'string' ? response : (response.text as string);
  }

  async implementWithFeedback(task: Task, plan: string): Promise<string> {
    // Initial implementation
    let code = await this.generateCode(task, plan);
    this.thinking.append(`Generated initial code\n`);

    // Verification loop
    for (let attempt = 0; attempt < 3; attempt++) {
      const verification = await this.verifyCode(code, task);

      if (verification.passed) {
        this.thinking.append(`Code verified successfully\n`);
        return code;
      }

      this.thinking.append(`Verification failed: ${verification.errors}\n`);
      this.thinking.append(`Attempting fix (attempt ${attempt + 1}/3)\n`);

      // Fix based on errors
      code = await this.fixCode(code, verification.errors!, task);
    }

    throw new Error('Could not produce working code after 3 attempts');
  }

  async generateCode(task: Task, plan: string): Promise<string> {
    const response = await llm.complete([
      { role: 'system', content: this.systemPrompt },
      { role: 'user', content: `Implement the following plan:

        Task: ${task.title}
        Description: ${task.description}

        Plan:
        ${plan}

        Write the complete code implementation.` }
    ]);

    return typeof response === 'string' ? response : (response.text as string);
  }

  async verifyCode(code: string, task: Task): Promise<{ passed: boolean; errors?: string }> {
    // In a real system, this would run tests, type checking, etc.
    const verification = await llm.complete([
      { role: 'system', content: 'You are a code reviewer. Check this code for correctness, completeness, and potential issues.' },
      { role: 'user', content: `Task: ${task.description}\n\nCode:\n${code}\n\nList any issues or confirm the code is correct.` }
    ]);

    const text = typeof verification === 'string' ? verification : (verification.text as string);

    const lower = text.toLowerCase();
    const hasIssues = lower.includes('issue') ||
                      lower.includes('error') ||
                      lower.includes('problem');

    return hasIssues
      ? { passed: false, errors: text }
      : { passed: true };
  }

  async fixCode(code: string, errors: string, task: Task): Promise<string> {
    const response = await llm.complete([
      { role: 'system', content: this.systemPrompt },
      { role: 'user', content: `Fix the following code based on the errors:

        Original task: ${task.description}

        Code:
        ${code}

        Errors found:
        ${errors}

        Provide the corrected code.` }
    ]);

    return typeof response === 'string' ? response : (response.text as string);
  }

  buildContext(task: Task): string {
    // In a real system, this would include relevant code files, documentation, etc.
    return `Task context for ${task.title}`;
  }
}

// research-worker.ts
export default class ResearchWorker extends AgenticSystem {
  @field workerId = 'research-worker-1';
  @field currentTask: Task | null = null;
  @field thinking: stream<string>('');
  @field findings: stream<Finding[]>([]);
  @field taskBoard: TaskBoardSystem;
  @field knowledge: VectorStore<Knowledge>;

  systemPrompt = `You are an expert researcher.
    You gather information from multiple sources, analyze it critically,
    and synthesize clear findings.

    When researching:
    1. Identify the key questions to answer
    2. Search for relevant information
    3. Evaluate source quality
    4. Synthesize findings
    5. Note gaps or uncertainties`;

  @schedule('every 2 minutes')
  async workCycle() {
    const tasks = this.taskBoard.getTasksForWorker(this.workerId);
    if (tasks.length === 0) return;

    this.currentTask = tasks[0];
    await this.executeResearch(this.currentTask);
  }

  async executeResearch(task: Task) {
    this.thinking.append(`Starting research: ${task.title}\n`);
    this.findings.reset([]);

    try {
      // Decompose into research questions
      const questions = await this.decomposeToQuestions(task);
      this.thinking.append(`Research questions:\n${questions.map((q, i) => `${i + 1}. ${q}`).join('\n')}\n`);

      // Research each question
      const allFindings: Finding[] = [];
      for (const question of questions) {
        this.thinking.append(`\nResearching: ${question}\n`);
        const questionFindings = await this.researchQuestion(question);
        allFindings.push(...questionFindings);

        // Update streaming findings
        this.findings.set([...allFindings]);
      }

      // Score and filter findings
      const scoredFindings = await this.scoreFindings(allFindings, task);
      const topFindings = scoredFindings
        .sort((a, b) => b.score - a.score)
        .slice(0, 10);

      this.findings.set(topFindings);

      // Synthesize into result
      const synthesis = await this.synthesize(topFindings, task);
      this.thinking.append(`\nSynthesis complete\n`);

      // Store valuable findings for future use
      await this.storeKnowledge(topFindings);

      // Complete task
      this.taskBoard.completeTask(task.id, synthesis);

    } catch (error: any) {
      this.thinking.append(`Error: ${error.message}\n`);
      this.taskBoard.blockTask(task.id, error.message);
    }

    this.currentTask = null;
  }

  async decomposeToQuestions(task: Task): Promise<string[]> {
    const response = await llm.complete([
      { role: 'system', content: this.systemPrompt },
      { role: 'user', content: `Break this research task into 3-5 specific questions:

        Task: ${task.title}
        Description: ${task.description}

        List the questions, one per line.` }
    ]);

    const text = typeof response === 'string' ? response : (response.text as string);
    return text.split('\n').filter(q => q.trim().length > 0);
  }

  async researchQuestion(question: string): Promise<Finding[]> {
    // Check existing knowledge first
    const existingKnowledge = await this.knowledge.search(question, 3);

    // Search for new information
    const searchResults = await this.search(question);

    // Combine and structure as findings
    const findings: Finding[] = [];

    for (const result of searchResults) {
      findings.push({
        content: result.content,
        source: result.source,
        relevance: 0, // Will be scored later
        score: 0
      });
    }

    // Add relevant existing knowledge
    for (const knowledge of existingKnowledge) {
      // search(question, 3) returns the top 3 items as
      // { item: Knowledge; similarity: number }[], similarity ∈ [0, 1]
      if (knowledge.similarity > 0.7) {
        findings.push({
          content: knowledge.item.content,
          source: 'knowledge-base',
          relevance: knowledge.similarity,
          score: 0
        });
      }
    }

    return findings;
  }

  async scoreFindings(findings: Finding[], task: Task): Promise<Finding[]> {
    // Score each finding for relevance and quality
    const scored = await Promise.all(findings.map(async finding => {
      const scoreResponse = await llm.complete([
        { role: 'system', content: 'Score this finding from 0-10 for relevance to the task and quality of information. Return only a number.' },
        { role: 'user', content: `Task: ${task.description}\n\nFinding: ${finding.content}\n\nReturn just a number 0-10.` }
      ]);

      const text = typeof scoreResponse === 'string' ? scoreResponse : (scoreResponse.text as string);
      let score = parseInt(text, 10);
      if (Number.isNaN(score)) {
        score = 5;
      }
      // Clamp between 0 and 10
      score = Math.max(0, Math.min(10, score));

      return {
        ...finding,
        score
      };
    }));

    return scored;
  }

  async synthesize(findings: Finding[], task: Task): Promise<string> {
    const response = await llm.complete([
      { role: 'system', content: this.systemPrompt },
      { role: 'user', content: `Synthesize these findings into a coherent research result:

        Task: ${task.title}
        Description: ${task.description}

        Findings:
        ${findings.map(f => `- ${f.content} (Source: ${f.source})`).join('\n')}

        Provide a clear synthesis addressing the original task. Note any gaps or uncertainties.` }
    ]);

    return typeof response === 'string' ? response : (response.text as string);
  }

  async storeKnowledge(findings: Finding[]) {
    for (const finding of findings) {
      if (finding.score >= 7) { // Only store high-quality findings
        await this.knowledge.insert({
          content: finding.content,
          source: finding.source,
          timestamp: Date.now()
        });
      }
    }
  }

  @tool({ description: 'Search for information on a topic' })
  async search(query: string): Promise<{ content: string; source: string }[]> {
    // In a real system, this would search the web, databases, etc.
    // For illustration, we return mock results
    return [
      { content: `Information about ${query}`, source: 'web-search' }
    ];
  }
}

interface Finding {
  content: string;
  source: string;
  relevance: number;
  score: number;
}

interface Knowledge {
  content: string;
  source: string;
  timestamp: number;
}

// Example VectorStore interface used by the knowledge field:
// interface VectorStore<T> {
//   search(query: string, k: number): Promise<{ item: T; similarity: number }[]>;
//   insert(item: T): Promise<void>;
// }

// writing-worker.ts
export default class WritingWorker extends AgenticSystem {
  @field workerId = 'writing-worker-1';
  @field currentTask: Task | null = null;
  @field thinking: stream<string>('');
  @field draft: stream<string>('');
  @field taskBoard: TaskBoardSystem;

  systemPrompt = `You are an expert writer.
    You produce clear, well-structured content appropriate for the audience.

    When writing:
    1. Understand the purpose and audience
    2. Create an outline
    3. Draft content
    4. Review and refine
    5. Polish final output`;

  @schedule('every 2 minutes')
  async workCycle() {
    const tasks = this.taskBoard.getTasksForWorker(this.workerId);
    if (tasks.length === 0) return;

    this.currentTask = tasks[0];
    await this.executeWriting(this.currentTask);
  }

  async executeWriting(task: Task) {
    this.thinking.append(`Starting writing task: ${task.title}\n`);
    this.draft.reset('');

    try {
      // Plan the document
      const outline = await this.createOutline(task);
      this.thinking.append(`Outline:\n${outline}\n`);

      // Draft with streaming
      await this.writeDraft(task, outline);

      // Self-critique
      const critique = await this.selfCritique(this.draft.current(), task);
      this.thinking.append(`Critique:\n${critique}\n`);

      // Revise based on critique
      const revised = await this.revise(this.draft.current(), critique, task);
      this.draft.set(revised);

      // Complete task
      this.taskBoard.completeTask(task.id, revised);
      this.thinking.append(`Writing complete\n`);

    } catch (error: any) {
      this.thinking.append(`Error: ${error.message}\n`);
      this.taskBoard.blockTask(task.id, error.message);
    }

    this.currentTask = null;
  }

  async createOutline(task: Task): Promise<string> {
    const response = await llm.complete([
      { role: 'system', content: this.systemPrompt },
      { role: 'user', content: `Create an outline for this writing task:

        Title: ${task.title}
        Description: ${task.description}

        ${task.feedback ? `Previous feedback to address: ${task.feedback}` : ''}

        Provide a structured outline with main sections and key points.` }
    ]);

    return typeof response === 'string' ? response : (response.text as string);
  }

  async writeDraft(task: Task, outline: string) {
    // Stream the draft as it's written
    const streamResult = llm.stream([
      { role: 'system', content: this.systemPrompt },
      { role: 'user', content: `Write the full content based on this outline:

        Task: ${task.title}
        Description: ${task.description}

        Outline:
        ${outline}

        Write clear, engaging prose. Follow the outline structure.` }
    ]);

    // llm.stream returns an async iterator of string chunks (partial model output).
    // We build the draft incrementally by appending each chunk.
    for await (const chunk of streamResult as AsyncIterable<string>) {
      this.draft.append(chunk);
    }
  }

  async selfCritique(draft: string, task: Task): Promise<string> {
    const response = await llm.complete([
      { role: 'system', content: 'You are a critical editor. Identify weaknesses and suggest improvements.' },
      { role: 'user', content: `Review this draft:

        Original task: ${task.description}

        Draft:
        ${draft}

        What could be improved? Be specific.` }
    ]);

    return typeof response === 'string' ? response : (response.text as string);
  }

  async revise(draft: string, critique: string, task: Task): Promise<string> {
    const response = await llm.complete([
      { role: 'system', content: this.systemPrompt },
      { role: 'user', content: `Revise this draft based on the feedback:

        Original task: ${task.description}

        Current draft:
        ${draft}

        Feedback to address:
        ${critique}

        Provide the improved version.` }
    ]);

    return typeof response === 'string' ? response : (response.text as string);
  }
}

// manager-interface.ts
export default class ManagerInterface extends AgenticSystem {
  @field coordinator: Coordinator;
  @field taskBoard: TaskBoardSystem;

  // Status views
  @field dashboard: stream<DashboardState>({ tasks: [], workers: [], alerts: [] });

  // ===== Task Management =====

  @action()
  async addTask(
    title: string,
    description: string,
    type: 'code' | 'research' | 'writing' | 'general',
    priority: 'high' | 'medium' | 'low' = 'medium'
  ): Promise<string> {
    const taskId = this.taskBoard.addTask({
      title,
      description,
      type,
      priority,
      assignedTo: null,
      startedAt: null,
      completedAt: null,
      result: null,
      feedback: null,
      metadata: {}
    });

    await this.updateDashboard();
    return taskId;
  }

  @action()
  async reviewTask(taskId: string, approved: boolean, feedback?: string) {
    if (approved) {
      this.taskBoard.approveTask(taskId);
    } else {
      this.taskBoard.rejectTask(taskId, feedback || 'Needs revision');
    }

    await this.updateDashboard();
  }

  @action()
  async handleEscalation(decision: 'reassign' | 'modify' | 'cancel', details?: string) {
    await this.coordinator.handleEscalation(decision, details);
    await this.updateDashboard();
  }

  // ===== Visibility =====

  @schedule('every 1 minute')
  async updateDashboard() {
    const tasks = this.taskBoard.board.tasks;
    const workers = Array.from(this.coordinator.workers.values());

    const alerts: Alert[] = [];

    // Alert for tasks in review
    const inReview = tasks.filter(t => t.status === 'review');
    if (inReview.length > 0) {
      alerts.push({
        type: 'review',
        message: `${inReview.length} task(s) awaiting review`,
        tasks: inReview.map(t => t.id)
      });
    }

    // Alert for escalations
    if (this.coordinator.pendingEscalation) {
      alerts.push({
        type: 'escalation',
        message: `Escalation: ${this.coordinator.pendingEscalation.reason}`,
        tasks: [this.coordinator.pendingEscalation.taskId]
      });
    }

    // Alert for blocked tasks
    const blocked = tasks.filter(t => t.status === 'blocked');
    if (blocked.length > 0) {
      alerts.push({
        type: 'blocked',
        message: `${blocked.length} task(s) blocked`,
        tasks: blocked.map(t => t.id)
      });
    }

    this.dashboard.set({
      tasks: tasks.map(t => ({
        id: t.id,
        title: t.title,
        status: t.status,
        assignedTo: t.assignedTo,
        priority: t.priority
      })),
      workers: workers.map(w => ({
        id: w.id,
        specialties: w.specialties,
        currentTasks: this.taskBoard.getTasksForWorker(w.id).length
      })),
      alerts
    });
  }

  // ===== Performance Metrics =====

  @action()
  getPerformanceReport(period: 'day' | 'week' | 'month'): PerformanceReport {
    const since = period === 'day' ? Date.now() - 86400000
                : period === 'week' ? Date.now() - 604800000
                : Date.now() - 2592000000;

    const completed = this.taskBoard.getCompletedTasks(since);
    const byType = this.groupBy(completed, 'type');
    const byWorker = this.groupBy(completed, 'assignedTo');

    const avgDuration = completed.length > 0
      ? completed.reduce((sum, t) => sum + (t.completedAt! - t.startedAt!), 0) / completed.length
      : 0;

    return {
      period,
      totalCompleted: completed.length,
      byType: Object.fromEntries(
        Object.entries(byType).map(([type, tasks]) => [type, tasks.length])
      ),
      byWorker: Object.fromEntries(
        Object.entries(byWorker).map(([worker, tasks]) => [
          worker || 'unassigned',
          {
            completed: tasks.length,
            avgDuration: tasks.reduce((sum, t) =>
              sum + (t.completedAt! - t.startedAt!), 0) / tasks.length
          }
        ])
      ),
      avgDurationMs: avgDuration
    };
  }

  private groupBy<T>(items: T[], key: keyof T): Record<string, T[]> {
    return items.reduce((groups, item) => {
      const value = String(item[key] || 'unknown');
      groups[value] = groups[value] || [];
      groups[value].push(item);
      return groups;
    }, {} as Record<string, T[]>);
  }
}

interface DashboardState {
  tasks: { id: string; title: string; status: string; assignedTo: string | null; priority: string }[];
  workers: { id: string; specialties: string[]; currentTasks: number }[];
  alerts: Alert[];
}

interface Alert {
  type: 'review' | 'escalation' | 'blocked';
  message: string;
  tasks: string[];
}

interface PerformanceReport {
  period: string;
  totalCompleted: number;
  byType: Record<string, number>;
  byWorker: Record<string, { completed: number; avgDuration: number }>;
  avgDurationMs: number;
}

// virtual-office.ts
export default class VirtualOffice extends AgenticSystem {
  // Core components
  @field taskBoard: TaskBoardSystem;
  @field coordinator: Coordinator;
  @field manager: ManagerInterface;

  // Workers
  @field codeWorker: CodeWorker;
  @field researchWorker: ResearchWorker;
  @field writingWorker: WritingWorker;

  // System status
  @field status: stream<string>('');

  async initialize() {
    this.status.append('Initializing Virtual Office...\n');

    // Create shared task board
    this.taskBoard = new TaskBoardSystem();

    // Create coordinator with task board reference
    this.coordinator = new Coordinator();
    this.coordinator.taskBoard = this.taskBoard;

    // Create workers with task board reference
    this.codeWorker = new CodeWorker();
    this.codeWorker.taskBoard = this.taskBoard;

    this.researchWorker = new ResearchWorker();
    this.researchWorker.taskBoard = this.taskBoard;

    this.writingWorker = new WritingWorker();
    this.writingWorker.taskBoard = this.taskBoard;

    // Register workers with coordinator
    this.coordinator.registerWorker('code-worker-1', {
      id: 'code-worker-1',
      specialties: ['code'],
      maxConcurrent: 2,
      metrics: {}
    });

    this.coordinator.registerWorker('research-worker-1', {
      id: 'research-worker-1',
      specialties: ['research'],
      maxConcurrent: 3,
      metrics: {}
    });

    this.coordinator.registerWorker('writing-worker-1', {
      id: 'writing-worker-1',
      specialties: ['writing'],
      maxConcurrent: 2,
      metrics: {}
    });

    // Create manager interface
    this.manager = new ManagerInterface();
    this.manager.coordinator = this.coordinator;
    this.manager.taskBoard = this.taskBoard;

    this.status.append('Virtual Office ready.\n');
    this.status.append(`Workers: code, research, writing\n`);
    this.status.append(`Awaiting tasks...\n`);
  }

  // ===== Public Interface =====

  @action()
  async addTask(
    title: string,
    description: string,
    type: 'code' | 'research' | 'writing' | 'general',
    priority: 'high' | 'medium' | 'low' = 'medium'
  ): Promise<string> {
    return await this.manager.addTask(title, description, type, priority);
  }

  @action()
  async reviewTask(taskId: string, approved: boolean, feedback?: string) {
    await this.manager.reviewTask(taskId, approved, feedback);
  }

  @action()
  async handleEscalation(decision: 'reassign' | 'modify' | 'cancel', details?: string) {
    await this.manager.handleEscalation(decision, details);
  }

  @action()
  getStatus(): string {
    return this.status.current();
  }

  @action()
  getDashboard(): DashboardState {
    return this.manager.dashboard.current();
  }

  @action()
  getPerformanceReport(period: 'day' | 'week' | 'month'): PerformanceReport {
    return this.manager.getPerformanceReport(period);
  }
}