bobs-workshop 0.3.3 → 3.1.1

package/dist/prompts/reviewer.js

@@ -1,289 +0,0 @@
-// src/prompts/reviewer.ts
-export const REVIEWER_PROMPT = `
-SYSTEM: You are **BOB REVIEWER**, a senior code reviewer and system analyst, responsible for comprehensive code review with improvement MANUAL creation.
-
-⚠️ ROLE EXECUTION NOTICE:
-When the orchestrator assigns you this role via bob.workshop, YOU must execute immediately.
-Do not wait for another "reviewer agent" or external process. The role assignment response
-will include specific numbered actions - start with action 1 immediately.
-
-GOAL:
-- Analyze existing code features or entire codebases
-- Identify improvement opportunities across performance, quality, and security domains
-- Create comprehensive improvement specifications for the engineer to implement
-
-⚠️ CRITICAL: MANUAL is a JSON file (.bob/specs/SPEC-*.json). DO NOT create separate markdown files for review documentation. ALL review findings must be stored within the MANUAL using bob.manual.update.
-
----
-
-TOOLCHAIN YOU CAN USE:
-• specTools:
-  - bob.manual.create(input)           // create a new manual with title and metadata
-  - bob.manual.update(input)           // update manual sections, logs, or state
-  - bob.manual.get(input)              // retrieve a specific manual by ID
-
-• searchTools:
-  - bob.code.search(input)             // unified lexical + semantic + structural search with phase: "reviewer" for vulnerability detection, quality analysis, and performance issues
-    Examples:
-    - Check dependencies: bob.code.search({ query: "show dependencies for src/api/auth.ts", phase: "reviewer" })
-    - Find unused code: bob.code.search({ query: "find unused exports", phase: "reviewer" })
-    - Analyze architecture: bob.code.search({ query: "check architecture", phase: "reviewer" })
-    - Find references: bob.code.search({ query: "find references to SecurityManager", phase: "reviewer" })
-
-• dashboardTools:
-  - bob.dashboard.launch()             // launch visual dashboard on port 4577
-
-• approvalTools:
-  - bob.approval.request(input)        // create user approval request
-  - bob.approval.status(input)         // check approval status
-
----
-
-WORKFLOW SEQUENCES
-1. Create improvement manual: Use bob.manual.create with title ending "-REVIEW" and state="draft"
-2. Conduct systematic review across 3 categories via bob.manual.update:
-   - Security: Authentication, authorization, input validation, data exposure
-   - Performance: Database queries, algorithms, caching, resource usage
-   - Quality: Code structure, testing, maintainability, documentation
-3. Build improvement manual sections (with validation):
-   Use bob.manual.update to write each section to the review section of the manual:
-   - executive summary: 
-      - analysis scope: [codebase/feature components analyzed]
-      - technology stack: [languages, frameworks, key tools]
-      - overall assessment: [Current state rating with detailed breakdown]
-      - improvement categories: [Performance: X issues, Quality: Y issues, Security: Z issues]
-      - implementation priority: [Critical: immediate, High: 30 days, Medium: 90 days]
-      - expected business impact: [Performance gains, maintainability improvements, security enhancements]
-   - existing specification context:
-      - related specifications: [list of existing specs and their relationships]
-      - implementation history: [previous architectural decisions and their outcomes]
-   - performance analysis:
-      - critical performance issues: [list of critical performance issues]
-      - optimization opportunities: [list of optimization opportunities]
-      - scalability enhancements: [list of scalability enhancements]
-      - expected performance gains: [list of expected performance gains]
-   - quality analysis:
-      - technical debt: [list of technical debt]
-      - testing enhancements: [list of testing enhancements]
-      - architecture improvements: [list of architecture improvements]
-      - documentation improvements: [list of documentation improvements]
-   - security analysis:
-      - security vulnerabilities: [list of security vulnerabilities]
-      - OWASP compliance gaps: [list of OWASP compliance gaps]
-      - data protection enhancements: [list of data protection enhancements]
-      - infrastructure security: [list of infrastructure security]
-   - implementation plan:
-      - critical fixes: [list of critical fixes]
-      - high-priority improvements: [list of high-priority improvements]
-      - medium-priority enhancements: [list of medium-priority enhancements]
-      - implementation strategy: [list of implementation strategy]
-      - success metrics: [list of success metrics]
-      - validation: [list of validation]
-      - risk assessment: [list of risk assessment]
-      - change management strategy: [list of change management strategy]
-   - implementation strategy:
-      - phase 1: [list of phase 1]
-      - phase 2: [list of phase 2]
-      - phase 3: [list of phase 3]
-
----
-
-THINKING FRAMEWORK
-
-1. **Codebase Structure & Technology Stack:**
-   - What languages, frameworks, and architectural patterns are used?
-   - What are the main components, modules, and their relationships?
-   - What testing frameworks, build systems, and deployment patterns exist?
-   - How is the codebase organized and what conventions are followed?
-
-2. **Existing Implementation Quality:**
-   - What are the current strengths and potential weaknesses?
-   - Are there obvious code smells, security vulnerabilities, or performance issues?
-   - How comprehensive is test coverage and documentation?
-   - What technical debt or maintenance challenges exist?
-
-3. **Improvement Opportunities:**
-   - Where are the highest-impact improvement opportunities?
-   - What would provide the most value: performance, security, or code quality?
-   - What changes would have immediate vs. long-term benefits?
-   - How can improvements be prioritized for maximum business impact?
-
-4. **Implementation Feasibility:**
-   - What improvements can be made incrementally vs. requiring major refactoring?
-   - Are there dependencies or constraints that limit improvement options?
-   - What would be the effort vs. benefit ratio for different improvements?
-   - How can changes be validated and tested safely?
-
----
-
-CODEBASE DISCOVERY PROTOCOL
-
-1. **Technology Stack Identification**:
-   - **Language Detection**: Identify primary programming languages and versions
-   - **Framework Analysis**: Map major frameworks (React, Django, Spring, etc.)
-   - **Build System**: Identify build tools (webpack, vite, Maven, pip, etc.)
-   - **Testing Stack**: Discover testing frameworks and coverage tools
-   - **Database & Infrastructure**: Identify data storage and deployment patterns
-
-2. **Existing MANUAL Discovery**:
-   - Search for related manuals using feature keywords
-   - Identify dependencies and relationships with existing manuals
-   - Analyze implementation history and previous architectural decisions
-   - Map feature evolution and maintenance patterns
-
-3. **Architecture Pattern Analysis**:
-   - Identify architectural layers and separation of concerns
-   - Analyze error handling, logging, and monitoring patterns
-   - Map data flow and state management approaches
-   - Assess configuration and environment management
-
----
-
-OUTPUT CONTRACT:
-Return JSON:
-{
-  "action": "await_approval",
-  "next_role": "none",
-  "spec_id": "<id>",
-  "workflow_step": "review",
-  "requires_user_input": true,
-  "approval_message": "Comprehensive review completed with improvement recommendations. Please review the findings and approve to proceed with implementation.",
-  "log_entry": "Reviewer completed comprehensive analysis; awaiting user approval to proceed",
-  "context": {
-    "sections_completed": ["executive_summary", "performance_analysis", "quality_analysis", "security_analysis", "implementation_plan"],
-    "findings_count": {
-      "performance": 5,
-      "quality": 8,
-      "security": 3
-    },
-    "priority_breakdown": {
-      "critical": 2,
-      "high": 6,
-      "medium": 8
-    },
-    "dashboard_url": "http://localhost:4577",
-    "approval_id": "<approval_request_id>"
-  }
-}
-
-If missing critical information, set action="clarify" and ask questions to the user to get the information.
-Once user approves, orchestrator will route to Engineer for implementation of improvements.
-
----
-
-REVIEW STANDARDS
-
-- Use bob.code.search with phase: "reviewer" for comprehensive vulnerability detection, quality analysis, and performance issues
-- Reference OWASP guidelines for security findings
-- Include performance benchmarks where applicable
-- Assess test coverage and code complexity
-
-- Performance Analysis
-   - Database performance: query optimization, indexing, connection pooling
-   - Application performance: algorithm efficiency, memory usage, CPU utilization
-   - Network performance: API response times, caching, CDN usage
-   - Frontend performance: bundle size, rendering optimization, lazy loading
-   - Infrastructure performance: scaling strategies, resource utilization
-
-- Quality Analysis
-   - Code structure: modularity, separation of concerns, architectural adherence
-   - Test coverage: unit test coverage, integration test completeness, E2E validation
-   - Technical debt: code smells, documentation gaps, maintenance challenges
-   - Best practices: framework conventions, error handling, logging strategies
-
-- Security Analysis
-   - Authentication security: session management, credential handling, multi-factor authentication
-   - Authorization controls: access control, privilege escalation, role-based permissions
-   - Input validation: SQL injection, XSS, CSRF protection, data sanitization
-   - Data protection: encryption at rest/transit, PII handling, secure storage
-   - Infrastructure security: HTTPS enforcement, security headers, dependency vulnerabilities
-
----
-
-VALIDATION REQUIREMENTS
-
-- All 3 categories must have findings or explicit "No issues found"
-- Each finding must include severity level and file references
-- Improvement manual must include prioritized remediation roadmap
-
----
-
-LOGGING CONTRACT:
-After completing review analysis, log via bob.manual.update with execution_log parameter.
-
-The tool will automatically create enhanced_activities with reviewer_data for dashboard display.
-
-**Standard Execution Log Format:**
-
-bob.manual.update({
-  spec_id,
-  execution_log: {
-    timestamp: new Date().toISOString(),
-    engineer: "reviewer",
-    action: "review:security_completed | review:performance_completed | review:quality_completed",
-    task_id: "SECURITY_REVIEW",
-    files_changed: [],
-    commit_hash: "pending",
-    note: "Security review completed. Found 5 issues (1 high, 2 medium, 2 low). ⚠️ Approved with conditions"
-  }
-})
-
-
-**Enhanced Activity Data (auto-generated by tool):**
-The tool automatically generates enhanced_activities for dashboard display:
-
-{
-  role: "reviewer",
-  type: "role_update",
-  summary: "Security review completed. Found 5 issues (1 high, 2 medium, 2 low). ⚠️ Approved with conditions",
-  reviewer_data: {
-    review_type: "security",  // code | architecture | security | performance
-    findings: [
-      {
-        severity: "high",  // high | medium | low
-        description: "JWT secret is hardcoded in auth.service.ts - should use environment variable",
-        file: "src/services/auth.service.ts"
-      },
-      {
-        severity: "medium",
-        description: "Password validation allows weak passwords (min 6 chars) - should require 8+ with complexity",
-        file: "src/utils/password.util.ts"
-      },
-      {
-        severity: "low",
-        description: "Auth service lacks logging for suspicious activity",
-        file: "src/services/auth.service.ts"
-      }
-    ],
-    approval_status: "conditional"  // approved | conditional | rejected
-  },
-  files_changed: []
-}
-
-
-**Review Types:**
-- **code**: Code quality, best practices, maintainability
-- **architecture**: System design, scalability, patterns
-- **security**: Authentication, authorization, data protection, OWASP compliance
-- **performance**: Speed, efficiency, resource usage, scalability
-
-**Approval Status:**
-- **approved**: ✅ No blocking issues, ready for deployment
-- **conditional**: ⚠️ Issues found but not blocking; address before next iteration
-- **rejected**: ❌ Critical issues must be fixed before proceeding
-
-**When to Log:**
-1. After completing each review category (security, performance, quality)
-2. After analyzing findings and determining severity
-3. When providing final approval status
-4. After creating improvement manual with recommendations
-
-**Dashboard Display:**
-Your logs appear in the Activity timeline with:
-- **Review type badge** (Security, Performance, Quality, Architecture)
-- **Findings grouped by severity** (High, Medium, Low)
-- **Issue descriptions** with file references
-- **Approval status badge** (✅ Approved / ⚠️ Conditional / ❌ Rejected)
-- **Summary statistics** (e.g., "5 issues: 1 high, 2 medium, 2 low")
-`;
-//# sourceMappingURL=reviewer.js.map

package/dist/prompts/reviewer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reviewer.js","sourceRoot":"","sources":["../../src/prompts/reviewer.ts"],"names":[],"mappings":"AAAA,0BAA0B;AAC1B,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8R9B,CAAC"}

package/dist/services/activitySummarizer.js

@@ -1,388 +0,0 @@
-// src/services/activitySummarizer.ts
-import { z } from "zod";
-// Enhanced Activity Schema
-export const EnhancedActivitySchema = z.object({
-    id: z.string(),
-    timestamp: z.string(),
-    role: z.enum(['architect', 'engineer', 'debugger', 'reviewer', 'orchestrator', 'system']),
-    type: z.enum(['role_update', 'layer_progress', 'clarification', 'file_change', 'mcp_operation', 'phase_completion']),
-    summary: z.string(),
-    details: z.string().optional(),
-    architect_data: z.object({
-        phase: z.enum(['research', 'design', 'clarification', 'planning']).optional(),
-        sections_completed: z.array(z.string()).optional(),
-        research_findings: z.array(z.string()).optional(),
-        design_decisions: z.array(z.string()).optional(),
-        clarifications: z.array(z.object({
-            question: z.string(),
-            answer: z.string().optional(),
-            status: z.enum(['pending', 'answered'])
-        })).optional()
-    }).optional(),
-    engineer_data: z.object({
-        layer: z.enum(['database', 'backend', 'frontend', 'integration', 'testing']).optional(),
-        tasks_completed: z.array(z.string()).optional(),
-        tasks_remaining: z.array(z.string()).optional(),
-        completion_percentage: z.number().optional(),
-        build_status: z.enum(['success', 'failed', 'skipped']).optional(),
-        test_status: z.enum(['passed', 'failed', 'skipped']).optional()
-    }).optional(),
-    debugger_data: z.object({
-        issue: z.string().optional(),
-        root_cause: z.string().optional(),
-        fix: z.string().optional(),
-        confidence: z.enum(['high', 'medium', 'low']).optional(),
-        affected_systems: z.array(z.string()).optional()
-    }).optional(),
-    reviewer_data: z.object({
-        review_type: z.enum(['code', 'architecture', 'security', 'performance']).optional(),
-        findings: z.array(z.object({
-            severity: z.enum(['high', 'medium', 'low']),
-            description: z.string(),
-            file: z.string().optional()
-        })).optional(),
-        approval_status: z.enum(['approved', 'conditional', 'rejected']).optional()
-    }).optional(),
-    orchestrator_data: z.object({
-        workflow_action: z.string().optional(),
-        coordinated_roles: z.array(z.string()).optional(),
-        milestones: z.array(z.string()).optional(),
-        blockers: z.array(z.string()).optional()
-    }).optional(),
-    files_changed: z.array(z.object({
-        path: z.string(),
-        change_type: z.enum(['added', 'modified', 'deleted']),
-        lines_added: z.number(),
-        lines_removed: z.number(),
-        diff_summary: z.string(),
-        category: z.enum(['backend', 'frontend', 'test', 'config', 'docs', 'other'])
-    }))
-});
-// State tracking for layer progress (in-memory, per spec)
-class LayerProgressTracker {
-    constructor() {
-        this.progress = new Map();
-    }
-    updateLayerProgress(specId, layer, tasksCompleted, tasksRemaining) {
-        if (!this.progress.has(specId)) {
-            this.progress.set(specId, {
-                current_layer: layer,
-                completed_layers: [],
-                layer_tasks: new Map()
-            });
-        }
-        const state = this.progress.get(specId);
-        state.current_layer = layer;
-        state.layer_tasks.set(layer, {
-            completed: tasksCompleted.length,
-            total: tasksCompleted.length + tasksRemaining.length
-        });
-        // Mark previous layers as completed
-        const layerOrder = ['database', 'backend', 'frontend', 'integration', 'testing'];
-        const currentIndex = layerOrder.indexOf(layer);
-        for (let i = 0; i < currentIndex; i++) {
-            if (!state.completed_layers.includes(layerOrder[i])) {
-                state.completed_layers.push(layerOrder[i]);
-            }
-        }
-    }
-    getProgress(specId) {
-        return this.progress.get(specId) || {
-            current_layer: 'database',
-            completed_layers: [],
-            layer_tasks: new Map()
-        };
-    }
-}
-const layerTracker = new LayerProgressTracker();
-// Categorize file by path
-function categorizeFile(filePath) {
-    const normalized = filePath.toLowerCase();
-    if (normalized.includes('test') || normalized.includes('spec') || normalized.includes('__tests__')) {
-        return 'test';
-    }
-    if (normalized.includes('frontend') || normalized.includes('ui') || normalized.includes('component') ||
-        normalized.includes('public') || normalized.endsWith('.html') || normalized.endsWith('.css')) {
-        return 'frontend';
-    }
-    if (normalized.includes('backend') || normalized.includes('server') || normalized.includes('api') ||
-        normalized.includes('service') || normalized.includes('controller') || normalized.includes('middleware')) {
-        return 'backend';
-    }
-    if (normalized.includes('config') || normalized.endsWith('.json') || normalized.endsWith('.yml') ||
-        normalized.endsWith('.yaml') || normalized.endsWith('.env')) {
-        return 'config';
-    }
-    if (normalized.endsWith('.md') || normalized.includes('doc') || normalized.includes('readme')) {
-        return 'docs';
-    }
-    return 'other';
-}
-// Generate intelligent summary based on role and data
-export function generateActivitySummary(role, data, files = []) {
-    switch (role) {
-        case 'architect':
-            return generateArchitectSummary(data, files);
-        case 'engineer':
-            return generateEngineerSummary(data, files);
-        case 'debugger':
-            return generateDebuggerSummary(data, files);
-        case 'reviewer':
-            return generateReviewerSummary(data, files);
-        case 'orchestrator':
-            return generateOrchestratorSummary(data, files);
-        case 'system':
-            return data.summary || 'System activity logged';
-        default:
-            return 'Activity logged';
-    }
-}
-function generateArchitectSummary(data, files) {
-    const parts = [];
-    // Phase completion
-    if (data.phase) {
-        const phaseMap = {
-            research: 'Completed research',
-            design: 'Completed design',
-            clarification: 'Requested clarifications',
-            planning: 'Completed planning'
-        };
-        parts.push(phaseMap[data.phase] || `Working on ${data.phase}`);
-    }
-    // Research findings
-    if (data.research_findings?.length) {
-        parts.push(`Found ${data.research_findings.length} key findings`);
-    }
-    // Design decisions
-    if (data.design_decisions?.length) {
-        const decisions = data.design_decisions.slice(0, 2).join(', ');
-        parts.push(`Design decisions: ${decisions}${data.design_decisions.length > 2 ? '...' : ''}`);
-    }
-    // Sections completed
-    if (data.sections_completed?.length) {
-        const sections = data.sections_completed.map((s) => s.replace(/_/g, ' ')).join(', ');
-        parts.push(`Completed sections: ${sections}`);
-    }
-    // Clarifications
-    if (data.clarifications?.length) {
-        const pending = data.clarifications.filter((c) => c.status === 'pending').length;
-        const answered = data.clarifications.filter((c) => c.status === 'answered').length;
-        if (pending > 0) {
-            parts.push(`⏳ Awaiting ${pending} clarification${pending > 1 ? 's' : ''}`);
-        }
-        if (answered > 0) {
-            parts.push(`✅ Answered ${answered} clarification${answered > 1 ? 's' : ''}`);
-        }
-    }
-    // Files
-    if (files.length > 0) {
-        parts.push(`Updated ${files.length} file${files.length > 1 ? 's' : ''}`);
-    }
-    return parts.length > 0 ? parts.join('. ') + '.' : 'Architecture work completed.';
-}
-function generateEngineerSummary(data, files) {
-    const parts = [];
-    // Layer progress
-    if (data.layer) {
-        const layerMap = {
-            database: 'Database',
-            backend: 'Backend',
-            frontend: 'Frontend',
-            integration: 'Integration',
-            testing: 'Testing'
-        };
-        const layerName = layerMap[data.layer] || data.layer;
-        if (data.completion_percentage !== undefined) {
-            parts.push(`Working on ${layerName} Layer (${data.completion_percentage}% complete)`);
-        }
-        else {
-            parts.push(`Working on ${layerName} Layer`);
-        }
-        // Task counts
-        if (data.tasks_completed?.length && data.tasks_remaining?.length) {
-            const total = data.tasks_completed.length + data.tasks_remaining.length;
-            parts.push(`${data.tasks_completed.length}/${total} tasks completed`);
-        }
-    }
-    // Build and test status
-    const statusParts = [];
-    if (data.build_status === 'success') {
-        statusParts.push('Build ✅');
-    }
-    else if (data.build_status === 'failed') {
-        statusParts.push('Build ❌');
-    }
-    if (data.test_status === 'passed') {
-        statusParts.push('Tests ✅');
-    }
-    else if (data.test_status === 'failed') {
-        statusParts.push('Tests ❌');
-    }
-    if (statusParts.length > 0) {
-        parts.push(statusParts.join(' '));
-    }
-    // Files modified
-    if (files.length > 0) {
-        const totalAdded = files.reduce((sum, f) => sum + f.lines_added, 0);
-        const totalRemoved = files.reduce((sum, f) => sum + f.lines_removed, 0);
-        parts.push(`Modified ${files.length} file${files.length > 1 ? 's' : ''} (+${totalAdded} -${totalRemoved})`);
-    }
-    return parts.length > 0 ? parts.join('. ') + '.' : 'Engineering work completed.';
-}
-function generateDebuggerSummary(data, files) {
-    const parts = [];
-    // Issue
-    if (data.issue) {
-        parts.push(`Fixed: ${data.issue}`);
-    }
-    // Root cause
-    if (data.root_cause) {
-        parts.push(`Root cause: ${data.root_cause}`);
-    }
-    // Fix applied
-    if (data.fix) {
-        parts.push(`Applied fix: ${data.fix}`);
-    }
-    // Confidence
-    if (data.confidence) {
-        const confidenceIcons = {
-            high: '🎯',
-            medium: '⚖️',
-            low: '❓'
-        };
-        const icon = confidenceIcons[data.confidence] || '';
-        parts.push(`${icon} Confidence: ${data.confidence}`);
-    }
-    // Affected systems
-    if (data.affected_systems?.length) {
-        parts.push(`Affected: ${data.affected_systems.join(', ')}`);
-    }
-    // Files
-    if (files.length > 0) {
-        const fileList = files.map(f => f.path.split('/').pop()).join(', ');
-        parts.push(`Modified: ${fileList}`);
-    }
-    return parts.length > 0 ? parts.join('. ') + '.' : 'Debug work completed.';
-}
-function generateReviewerSummary(data, files) {
-    const parts = [];
-    // Review type
-    if (data.review_type) {
-        const typeMap = {
-            code: 'Code review',
-            architecture: 'Architecture review',
-            security: 'Security review',
-            performance: 'Performance review'
-        };
-        parts.push(typeMap[data.review_type] || 'Review completed');
-    }
-    else {
-        parts.push('Review completed');
-    }
-    // Findings
-    if (data.findings?.length) {
-        const severityCounts = { high: 0, medium: 0, low: 0 };
-        data.findings.forEach((f) => {
-            if (severityCounts[f.severity] !== undefined) {
-                severityCounts[f.severity]++;
-            }
-        });
-        const findingParts = [];
-        if (severityCounts.high > 0)
-            findingParts.push(`${severityCounts.high} high`);
-        if (severityCounts.medium > 0)
-            findingParts.push(`${severityCounts.medium} medium`);
-        if (severityCounts.low > 0)
-            findingParts.push(`${severityCounts.low} low`);
-        if (findingParts.length > 0) {
-            parts.push(`Found ${data.findings.length} issue${data.findings.length > 1 ? 's' : ''} (${findingParts.join(', ')})`);
-        }
-    }
-    // Approval status
-    if (data.approval_status) {
-        const statusMap = {
-            approved: '✅ Approved',
-            conditional: '⚠️ Approved with conditions',
-            rejected: '❌ Rejected'
-        };
-        parts.push(statusMap[data.approval_status] || data.approval_status);
-    }
-    return parts.length > 0 ? parts.join('. ') + '.' : 'Review completed.';
-}
-function generateOrchestratorSummary(data, files) {
-    const parts = [];
-    // Workflow action
-    if (data.workflow_action) {
-        parts.push(data.workflow_action);
-    }
-    // Coordinated roles
-    if (data.coordinated_roles?.length) {
-        const roles = data.coordinated_roles.join(', ');
-        parts.push(`Coordinated: ${roles}`);
-    }
-    // Milestones
-    if (data.milestones?.length) {
-        if (data.milestones.length === 1) {
-            parts.push(`Milestone: ${data.milestones[0]}`);
-        }
-        else {
-            parts.push(`${data.milestones.length} milestones reached`);
-        }
-    }
-    // Blockers
-    if (data.blockers?.length) {
-        parts.push(`⚠️ ${data.blockers.length} blocker${data.blockers.length > 1 ? 's' : ''}`);
-    }
-    return parts.length > 0 ? parts.join('. ') + '.' : 'Workflow activity logged.';
-}
-// Create enhanced activity from input data
-export function createEnhancedActivity(specId, role, data, files = []) {
-    const timestamp = new Date().toISOString();
-    const id = `activity_${timestamp}_${Math.random().toString(36).substr(2, 9)}`;
-    // Enrich files with categorization and diff summary
-    const enrichedFiles = files.map(file => ({
-        path: file.path,
-        change_type: file.change_type,
-        lines_added: file.lines_added,
-        lines_removed: file.lines_removed,
-        diff_summary: file.lines_added > 0 || file.lines_removed > 0
-            ? `+${file.lines_added} -${file.lines_removed}`
-            : 'No changes',
-        category: categorizeFile(file.path)
-    }));
-    // Generate intelligent summary
-    const summary = data.summary || generateActivitySummary(role, data, enrichedFiles);
-    // Determine type
-    let type = 'role_update';
-    if (role === 'engineer' && data.layer)
-        type = 'layer_progress';
-    if (role === 'architect' && data.clarifications?.some((c) => c.status === 'pending'))
-        type = 'clarification';
-    if (files.length > 0)
-        type = 'file_change';
-    if (data.phase && (data.phase === 'research' || data.phase === 'design' || data.phase === 'planning'))
-        type = 'phase_completion';
-    // Update layer tracking for engineer
-    if (role === 'engineer' && data.layer && data.tasks_completed && data.tasks_remaining) {
-        layerTracker.updateLayerProgress(specId, data.layer, data.tasks_completed, data.tasks_remaining);
-    }
-    return {
-        id,
-        timestamp,
-        role,
-        type,
-        summary,
-        details: data.details,
-        architect_data: role === 'architect' ? data : undefined,
-        engineer_data: role === 'engineer' ? data : undefined,
-        debugger_data: role === 'debugger' ? data : undefined,
-        reviewer_data: role === 'reviewer' ? data : undefined,
-        orchestrator_data: role === 'orchestrator' ? data : undefined,
-        files_changed: enrichedFiles
-    };
-}
-// Get layer progress for a spec (used by frontend)
-export function getLayerProgress(specId) {
-    return layerTracker.getProgress(specId);
-}
-//# sourceMappingURL=activitySummarizer.js.map