@gitgov/core 1.0.1 → 1.0.2

package/dist/src/adapters/backlog_adapter/index.js

@@ -1,924 +0,0 @@
-import { createTaskRecord } from '../../factories/task_factory';
-import { createCycleRecord } from '../../factories/cycle_factory';
-import { RecordStore } from '../../store';
-import { IdentityAdapter } from '../identity_adapter';
-import { FeedbackAdapter } from '../feedback_adapter';
-import { ExecutionAdapter } from '../execution_adapter';
-import { ChangelogAdapter } from '../changelog_adapter';
-import { MetricsAdapter } from '../metrics_adapter';
-// Default configuration
-const DEFAULT_CONFIG = {
-    healthThresholds: {
-        taskMinScore: 50,
-        maxDaysInStage: 7,
-        systemMinScore: 60
-    }
-};
-/**
- * BacklogAdapter - The Facade/Mediator
- *
- * Implements Facade + Dependency Injection Pattern for testeable and configurable orchestration.
- * Acts as Mediator between Task/Cycle protocols and Workflow/Planning methodologies.
- */
-export class BacklogAdapter {
-    taskStore;
-    cycleStore;
-    feedbackStore;
-    changelogStore;
-    feedbackAdapter;
-    metricsAdapter;
-    workflowMethodologyAdapter;
-    identity;
-    eventBus;
-    config;
-    constructor(dependencies) {
-        // Data Layer
-        this.taskStore = dependencies.taskStore;
-        this.cycleStore = dependencies.cycleStore;
-        this.feedbackStore = dependencies.feedbackStore;
-        this.changelogStore = dependencies.changelogStore;
-        // Adapter Dependencies
-        this.feedbackAdapter = dependencies.feedbackAdapter;
-        this.metricsAdapter = dependencies.metricsAdapter;
-        // Business Rules & Infrastructure
-        this.workflowMethodologyAdapter = dependencies.workflowMethodologyAdapter;
-        this.identity = dependencies.identity;
-        this.eventBus = dependencies.eventBus;
-        // Configuration with defaults
-        this.config = dependencies.config || DEFAULT_CONFIG;
-        // Phase 3: Setup event subscriptions
-        this.setupEventSubscriptions();
-    }
-    /**
-     * Setup event subscriptions for Phase 3 event handlers
-     */
-    setupEventSubscriptions() {
-        this.eventBus.subscribe("feedback.created", (event) => this.handleFeedbackCreated(event));
-        this.eventBus.subscribe("feedback.status.changed", (event) => this.handleFeedbackResolved(event));
-        this.eventBus.subscribe("execution.created", (event) => this.handleExecutionCreated(event));
-        this.eventBus.subscribe("changelog.created", (event) => this.handleChangelogCreated(event));
-        this.eventBus.subscribe("cycle.status.changed", (event) => this.handleCycleStatusChanged(event));
-        this.eventBus.subscribe("system.daily_tick", (event) => this.handleDailyTick(event));
-    }
-    // ===== PHASE 1: TASK/CYCLE CRUD OPERATIONS (IMPLEMENTED) =====
-    /**
-     * Creates a new task with workflow validation
-     */
-    async createTask(payload, actorId) {
-        // 1. Build the record with factory
-        const validatedPayload = await createTaskRecord(payload);
-        // 2. Create unsigned record structure
-        const unsignedRecord = {
-            header: {
-                version: '1.0',
-                type: 'task',
-                payloadChecksum: 'will-be-calculated-by-signRecord',
-                signatures: [{
-                        keyId: actorId,
-                        role: 'author',
-                        signature: 'placeholder',
-                        timestamp: Date.now(),
-                        timestamp_iso: new Date().toISOString()
-                    }]
-            },
-            payload: validatedPayload,
-        };
-        // 3. Sign the record
-        const signedRecord = await this.identity.signRecord(unsignedRecord, actorId, 'author');
-        // 4. Persist the record with validation
-        await this.taskStore.write(signedRecord);
-        // 5. Emit event
-        this.eventBus.publish({
-            type: 'task.created',
-            timestamp: Date.now(),
-            source: 'backlog_adapter',
-            payload: {
-                taskId: validatedPayload.id,
-                actorId
-            },
-            metadata: {
-                eventId: `${Date.now()}-task-created-${validatedPayload.id}`,
-                timestamp: Date.now(),
-                sourceAdapter: 'backlog_adapter'
-            }
-        });
-        return validatedPayload;
-    }
-    /**
-     * Gets a specific task by ID
-     */
-    async getTask(taskId) {
-        const record = await this.taskStore.read(taskId);
-        return record ? record.payload : null;
-    }
-    /**
-     * Gets all tasks in the system
-     */
-    async getAllTasks() {
-        const ids = await this.taskStore.list();
-        const tasks = [];
-        for (const id of ids) {
-            const record = await this.taskStore.read(id);
-            if (record) {
-                tasks.push(record.payload);
-            }
-        }
-        return tasks;
-    }
-    /**
-     * Submits a task for review
-     */
-    async submitTask(taskId, actorId) {
-        // Read and validate task exists
-        const taskRecord = await this.taskStore.read(taskId);
-        if (!taskRecord) {
-            throw new Error(`RecordNotFoundError: Task not found: ${taskId}`);
-        }
-        const task = taskRecord.payload;
-        // Validate current status
-        if (task.status !== 'draft') {
-            throw new Error(`ProtocolViolationError: Task ${taskId} is not in draft status`);
-        }
-        // Get actor with proper typing
-        const actor = await this.getActor(actorId);
-        // Delegate to workflow methodology for validation
-        const transitionRule = await this.workflowMethodologyAdapter.getTransitionRule('draft', 'review', {
-            task,
-            actor,
-            signatures: taskRecord.header.signatures
-        });
-        if (!transitionRule) {
-            throw new Error(`ProtocolViolationError: Transition draft→review not allowed for task ${taskId}`);
-        }
-        // Update task status
-        const updatedPayload = { ...task, status: 'review' };
-        const updatedRecord = { ...taskRecord, payload: updatedPayload };
-        // Sign and persist
-        const signedRecord = await this.identity.signRecord(updatedRecord, actorId, 'submitter');
-        await this.taskStore.write(signedRecord);
-        // Emit event
-        this.eventBus.publish({
-            type: 'task.status.changed',
-            timestamp: Date.now(),
-            source: 'backlog_adapter',
-            payload: {
-                taskId,
-                oldStatus: 'draft',
-                newStatus: 'review',
-                actorId
-            }
-        });
-        return updatedPayload;
-    }
-    /**
-     * Approves a task for next stage with complete workflow validation
-     */
-    async approveTask(taskId, actorId) {
-        // 1. Read and validate task exists
-        const taskRecord = await this.taskStore.read(taskId);
-        if (!taskRecord) {
-            throw new Error(`RecordNotFoundError: Task not found: ${taskId}`);
-        }
-        const task = taskRecord.payload;
-        const actor = await this.getActor(actorId);
-        // 2. Determine target transition from available transitions
-        const availableTransitions = await this.getAvailableTransitions(task.status);
-        const approvalTransition = availableTransitions.find(transition => transition.requires?.signatures && Object.keys(transition.requires.signatures).length > 0);
-        if (!approvalTransition) {
-            throw new Error(`ProtocolViolationError: No approval transition available from ${task.status}`);
-        }
-        const targetState = approvalTransition.to;
-        // 3. Generate temporary signature for validation
-        const tempSignature = {
-            keyId: actorId,
-            role: 'approver',
-            signature: 'temp-signature',
-            timestamp: Date.now(),
-            timestamp_iso: new Date().toISOString()
-        };
-        // 4. Build complete validation context
-        const context = {
-            task,
-            actor,
-            signatures: [...taskRecord.header.signatures, tempSignature],
-            transitionTo: targetState
-        };
-        // 5. Delegate signature validation to methodology
-        const isValidSignature = await this.workflowMethodologyAdapter.validateSignature(tempSignature, context);
-        if (!isValidSignature) {
-            throw new Error(`ProtocolViolationError: Signature is not valid for this approval`);
-        }
-        // 6. Update, sign and persist if validation successful
-        const updatedPayload = { ...task, status: targetState };
-        const updatedRecord = { ...taskRecord, payload: updatedPayload };
-        const signedRecord = await this.identity.signRecord(updatedRecord, actorId, 'approver');
-        await this.taskStore.write(signedRecord);
-        // 7. Emit event
-        this.eventBus.publish({
-            type: 'task.status.changed',
-            timestamp: Date.now(),
-            source: 'backlog_adapter',
-            payload: {
-                taskId,
-                oldStatus: task.status,
-                newStatus: targetState,
-                actorId
-            }
-        });
-        return updatedPayload;
-    }
-    /**
-     * Activates a task transitioning from ready to active with permission validation
-     */
-    async activateTask(taskId, actorId) {
-        // 1. Read and validate task exists
-        const taskRecord = await this.taskStore.read(taskId);
-        if (!taskRecord) {
-            throw new Error(`RecordNotFoundError: Task not found: ${taskId}`);
-        }
-        const task = taskRecord.payload;
-        const actor = await this.getActor(actorId);
-        // 2. Validate current status is 'ready'
-        if (task.status !== 'ready') {
-            throw new Error(`ProtocolViolationError: Task is in '${task.status}' state. Cannot activate from this state.`);
-        }
-        // 3. Validate transition with WorkflowMethodology
-        const context = {
-            task,
-            actor,
-            signatures: taskRecord.header.signatures,
-            transitionTo: 'active'
-        };
-        const transitionRule = await this.workflowMethodologyAdapter.getTransitionRule('ready', 'active', context);
-        if (!transitionRule) {
-            throw new Error(`ProtocolViolationError: Workflow methodology rejected ready→active transition`);
-        }
-        // 4. Update task status to 'active'
-        const updatedPayload = { ...task, status: 'active' };
-        const updatedRecord = { ...taskRecord, payload: updatedPayload };
-        // 5. Sign the record with 'executor' role
-        const signedRecord = await this.identity.signRecord(updatedRecord, actorId, 'executor');
-        await this.taskStore.write(signedRecord);
-        // 6. Emit task status changed event
-        this.eventBus.publish({
-            type: 'task.status.changed',
-            timestamp: Date.now(),
-            source: 'backlog_adapter',
-            payload: {
-                taskId,
-                oldStatus: 'ready',
-                newStatus: 'active',
-                actorId
-            }
-        });
-        return updatedPayload;
-    }
-    /**
-     * Resumes a paused task transitioning back to active with optional force override
-     */
-    async resumeTask(taskId, actorId, force = false) {
-        // 1. Read and validate task exists
-        const taskRecord = await this.taskStore.read(taskId);
-        if (!taskRecord) {
-            throw new Error(`RecordNotFoundError: Task not found: ${taskId}`);
-        }
-        const task = taskRecord.payload;
-        // 2. Validate current status is 'paused'
-        if (task.status !== 'paused') {
-            throw new Error(`ProtocolViolationError: Task is in '${task.status}' state. Cannot resume (requires paused).`);
-        }
-        // 3. Resolve actor and validate permissions via workflow methodology
-        const actor = await this.getActor(actorId);
-        if (!force) {
-            const taskHealth = await this.metricsAdapter.getTaskHealth(task.id);
-            if (taskHealth.blockingFeedbacks > 0) {
-                throw new Error('BlockingFeedbackError: Task has blocking feedbacks. Resolve them before resuming or use force.');
-            }
-        }
-        const context = {
-            task,
-            actor,
-            signatures: taskRecord.header.signatures,
-            transitionTo: 'active'
-        };
-        const transitionRule = await this.workflowMethodologyAdapter.getTransitionRule('paused', 'active', context);
-        if (!transitionRule) {
-            throw new Error('ProtocolViolationError: Workflow methodology rejected paused→active transition');
-        }
-        // 4. Update task status back to 'active'
-        const updatedPayload = { ...task, status: 'active' };
-        const updatedRecord = { ...taskRecord, payload: updatedPayload };
-        // 5. Sign and persist with resumer role
-        const signedRecord = await this.identity.signRecord(updatedRecord, actorId, 'resumer');
-        await this.taskStore.write(signedRecord);
-        // 6. Emit task status changed event
-        this.eventBus.publish({
-            type: 'task.status.changed',
-            timestamp: Date.now(),
-            source: 'backlog_adapter',
-            payload: {
-                taskId,
-                oldStatus: 'paused',
-                newStatus: 'active',
-                actorId
-            }
-        });
-        return updatedPayload;
-    }
-    /**
-     * Completes a task transitioning from active to done with signature validation
-     */
-    async completeTask(taskId, actorId) {
-        // 1. Read and validate task exists
-        const taskRecord = await this.taskStore.read(taskId);
-        if (!taskRecord) {
-            throw new Error(`RecordNotFoundError: Task not found: ${taskId}`);
-        }
-        const task = taskRecord.payload;
-        const actor = await this.getActor(actorId);
-        // 2. Validate current status is 'active'
-        if (task.status !== 'active') {
-            throw new Error(`ProtocolViolationError: Task is in '${task.status}' state. Cannot complete from this state.`);
-        }
-        // 3. Validate transition with WorkflowMethodology
-        const context = {
-            task,
-            actor,
-            signatures: taskRecord.header.signatures,
-            transitionTo: 'done'
-        };
-        const transitionRule = await this.workflowMethodologyAdapter.getTransitionRule('active', 'done', context);
-        if (!transitionRule) {
-            throw new Error(`ProtocolViolationError: Workflow methodology rejected active→done transition`);
-        }
-        // 4. Update task status to 'done'
-        const updatedPayload = { ...task, status: 'done' };
-        const updatedRecord = { ...taskRecord, payload: updatedPayload };
-        // 5. Sign the record with 'approver' role
-        const signedRecord = await this.identity.signRecord(updatedRecord, actorId, 'approver');
-        await this.taskStore.write(signedRecord);
-        // 6. Emit task status changed event
-        this.eventBus.publish({
-            type: 'task.status.changed',
-            timestamp: Date.now(),
-            source: 'backlog_adapter',
-            payload: {
-                taskId,
-                oldStatus: 'active',
-                newStatus: 'done',
-                actorId
-            }
-        });
-        return updatedPayload;
-    }
-    /**
-     * Discards a task transitioning from ready/active/review to discarded
-     * Supports both cancellation (ready/active) and rejection (review) operations
-     */
-    async discardTask(taskId, actorId, reason) {
-        // 1. Read and validate task exists
-        const taskRecord = await this.taskStore.read(taskId);
-        if (!taskRecord) {
-            throw new Error(`RecordNotFoundError: Task not found: ${taskId}`);
-        }
-        const task = taskRecord.payload;
-        const actor = await this.getActor(actorId);
-        // 2. Validate current status allows cancellation/rejection
-        if (!['ready', 'active', 'review'].includes(task.status)) {
-            throw new Error(`ProtocolViolationError: Task is in '${task.status}' state. Cannot cancel from this state. Only 'ready', 'active', and 'review' tasks can be cancelled.`);
-        }
-        // 3. Validate transition with WorkflowMethodology
-        const context = {
-            task,
-            actor,
-            signatures: taskRecord.header.signatures,
-            transitionTo: 'discarded'
-        };
-        const transitionRule = await this.workflowMethodologyAdapter.getTransitionRule(task.status, 'discarded', context);
-        if (!transitionRule) {
-            throw new Error(`ProtocolViolationError: Workflow methodology rejected ${task.status}→discarded transition`);
-        }
-        // 4. Update task status to 'discarded' and add cancellation/rejection reason
-        const updatedPayload = {
-            ...task,
-            status: 'discarded',
-            // Add reason to notes with appropriate prefix based on current state
-            ...(reason && {
-                notes: `${task.notes || ''}\n${task.status === 'review' ? '[REJECTED]' : '[CANCELLED]'} ${reason} (${new Date().toISOString()})`.trim()
-            })
-        };
-        const updatedRecord = { ...taskRecord, payload: updatedPayload };
-        // 5. Sign the record with 'canceller' role
-        const signedRecord = await this.identity.signRecord(updatedRecord, actorId, 'canceller');
-        await this.taskStore.write(signedRecord);
-        // 6. Emit task status changed event
-        this.eventBus.publish({
-            type: 'task.status.changed',
-            timestamp: Date.now(),
-            source: 'backlog_adapter',
-            payload: {
-                taskId,
-                oldStatus: task.status,
-                newStatus: 'discarded',
-                actorId,
-                reason: reason || (task.status === 'review' ? 'Task rejected' : 'Task cancelled')
-            }
-        });
-        return updatedPayload;
-    }
-    /**
-     * Updates a task with new payload
-     */
-    async updateTask(taskId, payload) {
-        const taskRecord = await this.taskStore.read(taskId);
-        if (!taskRecord) {
-            throw new Error(`RecordNotFoundError: Task not found: ${taskId}`);
-        }
-        // Validate not in final state
-        if (['archived'].includes(taskRecord.payload.status)) {
-            throw new Error(`ProtocolViolationError: Cannot update task in final state: ${taskRecord.payload.status}`);
-        }
-        // Merge and validate with factory
-        const updatedPayload = await createTaskRecord({ ...taskRecord.payload, ...payload });
-        const updatedRecord = { ...taskRecord, payload: updatedPayload };
-        await this.taskStore.write(updatedRecord);
-        return updatedPayload;
-    }
-    // ===== PHASE 2: AGENT NAVIGATION (IMPLEMENTED) =====
-    /**
-     * Gets tasks assigned to a specific actor
-     */
-    async getTasksAssignedToActor(actorId) {
-        // Read all feedbacks to find assignments
-        const feedbackIds = await this.feedbackStore.list();
-        const assignedTaskIds = [];
-        for (const id of feedbackIds) {
-            const record = await this.feedbackStore.read(id);
-            if (record &&
-                record.payload.type === 'assignment' &&
-                record.payload.assignee === actorId) {
-                assignedTaskIds.push(record.payload.entityId);
-            }
-        }
-        // Read the assigned tasks
-        const assignedTasks = [];
-        for (const taskId of assignedTaskIds) {
-            const task = await this.getTask(taskId);
-            if (task) {
-                assignedTasks.push(task);
-            }
-        }
-        return assignedTasks;
-    }
-    // ===== PHASE 3: EVENT HANDLERS (NEW IMPLEMENTATION) =====
-    /**
-     * [EARS-31] Handles feedback created events - pauses task if blocking
-     */
-    async handleFeedbackCreated(event) {
-        try {
-            const metadata = {
-                eventId: `${Date.now()}-handle-feedback-created`,
-                timestamp: Date.now(),
-                processedAt: Date.now(),
-                sourceAdapter: 'backlog_adapter'
-            };
-            // Only handle blocking feedbacks
-            if (event.payload.type !== 'blocking') {
-                return; // EARS-32: Do nothing for non-blocking feedback
-            }
-            // Read the associated task through feedback record
-            const feedbackRecord = await this.feedbackStore.read(event.payload.feedbackId);
-            if (!feedbackRecord) {
-                console.warn(`Feedback not found: ${event.payload.feedbackId}`);
-                return;
-            }
-            const task = await this.getTask(feedbackRecord.payload.entityId);
-            if (!task) {
-                console.warn(`Task not found for feedback: ${feedbackRecord.payload.entityId}`);
-                return;
-            }
-            // Only pause if task is in a pausable state
-            if (!['active', 'ready'].includes(task.status)) {
-                return;
-            }
-            // Update task to paused
-            const updatedTask = { ...task, status: 'paused' };
-            const taskRecord = await this.taskStore.read(task.id);
-            if (taskRecord) {
-                const updatedRecord = { ...taskRecord, payload: updatedTask };
-                await this.taskStore.write(updatedRecord);
-                // Emit status change event
-                this.eventBus.publish({
-                    type: 'task.status.changed',
-                    timestamp: Date.now(),
-                    source: 'backlog_adapter',
-                    payload: {
-                        taskId: task.id,
-                        oldStatus: task.status,
-                        newStatus: 'paused',
-                        actorId: 'system'
-                    },
-                    metadata
-                });
-            }
-        }
-        catch (error) {
-            console.error('Error in handleFeedbackCreated:', error);
-        }
-    }
-    /**
-     * [EARS-33] Handles feedback resolved events - resumes task if no more blocks
-     */
-    async handleFeedbackResolved(event) {
-        try {
-            // Only handle resolution of blocking feedbacks
-            if (event.payload.oldStatus !== 'open' || event.payload.newStatus !== 'resolved') {
-                return;
-            }
-            // Get the task through feedback record
-            const feedbackRecord = await this.feedbackStore.read(event.payload.feedbackId);
-            if (!feedbackRecord) {
-                return;
-            }
-            const task = await this.getTask(feedbackRecord.payload.entityId);
-            if (!task || task.status !== 'paused') {
-                return;
-            }
-            // EARS-33: Use MetricsAdapter to check for remaining blocks
-            const taskHealth = await this.metricsAdapter.getTaskHealth(task.id);
-            // EARS-34: Don't resume if other blocking feedbacks remain
-            if (taskHealth.blockingFeedbacks > 0) {
-                return;
-            }
-            // Resume task to active (assuming it was active before being paused)
-            const updatedTask = { ...task, status: 'active' };
-            const taskRecord = await this.taskStore.read(task.id);
-            if (taskRecord) {
-                const updatedRecord = { ...taskRecord, payload: updatedTask };
-                await this.taskStore.write(updatedRecord);
-                this.eventBus.publish({
-                    type: 'task.status.changed',
-                    timestamp: Date.now(),
-                    source: 'backlog_adapter',
-                    payload: {
-                        taskId: task.id,
-                        oldStatus: 'paused',
-                        newStatus: 'active',
-                        actorId: 'system'
-                    }
-                });
-            }
-        }
-        catch (error) {
-            console.error('Error in handleFeedbackResolved:', error);
-        }
-    }
-    /**
-     * [EARS-35] Handles execution created events - transitions ready→active on first execution
-     */
-    async handleExecutionCreated(event) {
-        try {
-            // EARS-35: Use ExecutionAdapter isFirstExecution logic
-            if (!event.payload.isFirstExecution) {
-                return; // EARS-36: Do nothing on subsequent executions
-            }
-            const task = await this.getTask(event.payload.taskId);
-            if (!task || task.status !== 'ready') {
-                return;
-            }
-            // EARS-36: Validate with WorkflowMethodology before transition
-            const actor = await this.getActor(event.payload.triggeredBy);
-            const transitionRule = await this.workflowMethodologyAdapter.getTransitionRule('ready', 'active', {
-                task,
-                actor,
-                signatures: []
-            });
-            if (!transitionRule) {
-                console.warn(`Workflow methodology rejected ready→active transition for task ${task.id}`);
-                return;
-            }
-            // Transition to active
-            const updatedTask = { ...task, status: 'active' };
-            const taskRecord = await this.taskStore.read(task.id);
-            if (taskRecord) {
-                const updatedRecord = { ...taskRecord, payload: updatedTask };
-                await this.taskStore.write(updatedRecord);
-                this.eventBus.publish({
-                    type: 'task.status.changed',
-                    timestamp: Date.now(),
-                    source: 'backlog_adapter',
-                    payload: {
-                        taskId: task.id,
-                        oldStatus: 'ready',
-                        newStatus: 'active',
-                        actorId: event.payload.triggeredBy
-                    }
-                });
-            }
-        }
-        catch (error) {
-            console.error('Error in handleExecutionCreated:', error);
-        }
-    }
-    /**
-     * [EARS-37] Handles changelog created events - transitions done→archived
-     */
-    async handleChangelogCreated(event) {
-        try {
-            // Get changelog record to access entityType and entityId
-            const changelogRecord = await this.changelogStore.read(event.payload.changelogId);
-            if (!changelogRecord) {
-                console.warn(`Changelog not found: ${event.payload.changelogId}`);
-                return;
-            }
-            // EARS-37: Only handle task-related changelogs
-            if (changelogRecord.payload.entityType !== 'task') {
-                return;
-            }
-            const task = await this.getTask(changelogRecord.payload.entityId);
-            if (!task || task.status !== 'done') {
-                return;
-            }
-            // Transition to archived
-            const updatedTask = { ...task, status: 'archived' };
-            const taskRecord = await this.taskStore.read(task.id);
-            if (taskRecord) {
-                const updatedRecord = { ...taskRecord, payload: updatedTask };
-                await this.taskStore.write(updatedRecord);
-                this.eventBus.publish({
-                    type: 'task.status.changed',
-                    timestamp: Date.now(),
-                    source: 'backlog_adapter',
-                    payload: {
-                        taskId: task.id,
-                        oldStatus: 'done',
-                        newStatus: 'archived',
-                        actorId: 'system'
-                    }
-                });
-            }
-        }
-        catch (error) {
-            console.error('Error in handleChangelogCreated:', error);
-        }
-    }
-    /**
-     * [EARS-38] Handles daily tick events - proactive health auditing
-     */
-    async handleDailyTick(_event) {
-        try {
-            // EARS-38: Use MetricsAdapter for proactive auditing
-            const systemStatus = await this.metricsAdapter.getSystemStatus();
-            // Get all active tasks for health analysis
-            const allTasks = await this.getAllTasks();
-            const activeTasks = allTasks.filter(task => task.status === 'active');
-            for (const task of activeTasks) {
-                const taskHealth = await this.metricsAdapter.getTaskHealth(task.id);
-                // Apply configurable health thresholds
-                if (taskHealth.healthScore < this.config.healthThresholds.taskMinScore ||
-                    taskHealth.timeInCurrentStage > this.config.healthThresholds.maxDaysInStage) {
-                    // Create automated warning feedback
-                    await this.feedbackAdapter.create({
-                        entityType: 'task',
-                        entityId: task.id,
-                        type: 'suggestion',
-                        content: `Automated health warning: Task health score is ${taskHealth.healthScore}%. ${taskHealth.recommendations.join('. ')}.`,
-                        status: 'open'
-                    }, 'system');
-                }
-            }
-            // Log system health alert if critical issues (no custom event needed)
-            if (systemStatus.health.overallScore < this.config.healthThresholds.systemMinScore) {
-                console.warn(`System health alert: Score ${systemStatus.health.overallScore}%, blocked: ${systemStatus.health.blockedTasks}, stale: ${systemStatus.health.staleTasks}`);
-                // Note: Health alerts are logged, not emitted as events. 
-                // System monitoring should read logs for alerting.
-            }
-        }
-        catch (error) {
-            console.error('Error in handleDailyTick:', error);
-        }
-    }
-    /**
-     * [EARS-45] Handles cycle status changed events - manages cycle hierarchy completion
-     */
-    async handleCycleStatusChanged(event) {
-        try {
-            // Only handle cycle completion
-            if (event.payload.newStatus !== 'completed') {
-                return;
-            }
-            const completedCycle = await this.getCycle(event.payload.cycleId);
-            if (!completedCycle) {
-                console.warn(`Completed cycle not found: ${event.payload.cycleId}`);
-                return;
-            }
-            // Find parent cycles that contain this completed cycle
-            const allCycles = await this.getAllCycles();
-            const parentCycles = allCycles.filter(cycle => cycle.childCycleIds?.includes(event.payload.cycleId));
-            for (const parentCycle of parentCycles) {
-                // Check if ALL child cycles are completed
-                const childCycles = await Promise.all((parentCycle.childCycleIds || []).map(id => this.getCycle(id)));
-                const allChildrenCompleted = childCycles.every(child => child && child.status === 'completed');
-                if (allChildrenCompleted) {
-                    // Complete the parent cycle
-                    await this.updateCycle(parentCycle.id, { status: 'completed' });
-                    // TODO: Delegate epic task completion to planning methodology
-                    // The logic for completing epic tasks based on cycle completion
-                    // should be handled by planningMethodology, not backlogAdapter
-                    /*
-                    if (this.planningMethodology) {
-                      await this.planningMethodology.handleEpicCompletion({
-                        completedCycleId: parentCycle.id,
-                        event
-                      });
-                    }
-                    */
-                    // For now, just log the completion - epic logic will be in planning methodology
-                    console.log(`Parent cycle ${parentCycle.id} completed - epic task completion delegated to planning methodology`);
-                }
-            }
-        }
-        catch (error) {
-            console.error('Error in handleCycleStatusChanged:', error);
-        }
-    }
-    // ===== PHASE 4: STUBS AND POLISH (DELEGATE TO ADAPTERS) =====
-    /**
-     * Gets system status by delegating to MetricsAdapter
-     */
-    async getSystemStatus() {
-        return await this.metricsAdapter.getSystemStatus();
-    }
-    /**
-     * Gets task health by delegating to MetricsAdapter
-     */
-    async getTaskHealth(taskId) {
-        return await this.metricsAdapter.getTaskHealth(taskId);
-    }
-    // ===== HELPER METHODS =====
-    /**
-     * Helper to get actor record
-     */
-    async getActor(actorId) {
-        // Use IdentityAdapter to get real actor data
-        const actor = await this.identity.getActor(actorId);
-        if (!actor) {
-            throw new Error(`RecordNotFoundError: Actor not found: ${actorId}`);
-        }
-        return actor;
-    }
-    /**
-     * Helper to get available transitions from current state
-     */
-    async getAvailableTransitions(fromStatus) {
-        // This would normally be implemented using workflowMethodology.getAvailableTransitions()
-        // For now, implementing basic logic based on canonical workflow
-        const transitions = [
-            { from: 'review', to: 'ready', requires: { signatures: { __default__: { role: 'approver' } } } },
-            { from: 'active', to: 'done', requires: { signatures: { __default__: { role: 'approver' } } } }
-        ];
-        return transitions.filter(t => t.from === fromStatus);
-    }
-    // ===== PHASE 1: CYCLE CRUD OPERATIONS (IMPLEMENTED) =====
-    /**
-     * Creates a new cycle with workflow validation
-     */
-    async createCycle(payload, actorId) {
-        // 1. Build the record with factory
-        const validatedPayload = await createCycleRecord(payload);
-        // 2. Create unsigned record structure
-        const unsignedRecord = {
-            header: {
-                version: '1.0',
-                type: 'cycle',
-                payloadChecksum: 'will-be-calculated-by-signRecord',
-                signatures: [{
-                        keyId: actorId,
-                        role: 'author',
-                        signature: 'placeholder',
-                        timestamp: Date.now(),
-                        timestamp_iso: new Date().toISOString()
-                    }]
-            },
-            payload: validatedPayload,
-        };
-        // 3. Sign the record
-        const signedRecord = await this.identity.signRecord(unsignedRecord, actorId, 'author');
-        // 4. Persist the record
-        await this.cycleStore.write(signedRecord);
-        // 5. Emit event
-        this.eventBus.publish({
-            type: 'cycle.created',
-            timestamp: Date.now(),
-            source: 'backlog_adapter',
-            payload: {
-                cycleId: validatedPayload.id,
-                actorId
-            },
-            metadata: {
-                eventId: `${Date.now()}-cycle-created-${validatedPayload.id}`,
-                timestamp: Date.now(),
-                sourceAdapter: 'backlog_adapter'
-            }
-        });
-        return validatedPayload;
-    }
-    /**
-     * Gets a specific cycle by ID
-     */
-    async getCycle(cycleId) {
-        const record = await this.cycleStore.read(cycleId);
-        return record ? record.payload : null;
-    }
-    /**
-     * Gets all cycles in the system
-     */
-    async getAllCycles() {
-        const ids = await this.cycleStore.list();
-        const cycles = [];
-        for (const id of ids) {
-            const record = await this.cycleStore.read(id);
-            if (record) {
-                cycles.push(record.payload);
-            }
-        }
-        return cycles;
-    }
-    /**
-     * Updates a cycle with new payload
-     */
-    async updateCycle(cycleId, payload) {
-        const cycleRecord = await this.cycleStore.read(cycleId);
-        if (!cycleRecord) {
-            throw new Error(`RecordNotFoundError: Cycle not found: ${cycleId}`);
-        }
-        // Validate not in final state
-        if (['archived'].includes(cycleRecord.payload.status)) {
-            throw new Error(`ProtocolViolationError: Cannot update cycle in final state: ${cycleRecord.payload.status}`);
-        }
-        // Merge and validate with factory
-        const updatedPayload = await createCycleRecord({ ...cycleRecord.payload, ...payload });
-        const updatedRecord = { ...cycleRecord, payload: updatedPayload };
-        // Emit event if status changed
-        if (cycleRecord.payload.status !== updatedPayload.status) {
-            this.eventBus.publish({
-                type: 'cycle.status.changed',
-                timestamp: Date.now(),
-                source: 'backlog_adapter',
-                payload: {
-                    cycleId,
-                    oldStatus: cycleRecord.payload.status,
-                    newStatus: updatedPayload.status,
-                    actorId: 'system'
-                }
-            });
-        }
-        await this.cycleStore.write(updatedRecord);
-        return updatedPayload;
-    }
-    /**
-     * Creates bidirectional link between task and cycle
-     */
-    async addTaskToCycle(cycleId, taskId) {
-        // Read both records
-        const cycleRecord = await this.cycleStore.read(cycleId);
-        const taskRecord = await this.taskStore.read(taskId);
-        if (!cycleRecord) {
-            throw new Error(`RecordNotFoundError: Cycle not found: ${cycleId}`);
-        }
-        if (!taskRecord) {
-            throw new Error(`RecordNotFoundError: Task not found: ${taskId}`);
-        }
-        // Create bidirectional links
-        const updatedCycle = {
-            ...cycleRecord.payload,
-            taskIds: [...(cycleRecord.payload.taskIds || []), taskId]
-        };
-        const updatedTask = {
-            ...taskRecord.payload,
-            cycleIds: [...(taskRecord.payload.cycleIds || []), cycleId]
-        };
-        // Get current actor for signing (MVP mode)
-        const currentActor = await this.identity.getCurrentActor();
-        // Sign and persist both records with current actor
-        const signedCycleRecord = await this.identity.signRecord({ ...cycleRecord, payload: updatedCycle }, currentActor.id, 'author');
-        const signedTaskRecord = await this.identity.signRecord({ ...taskRecord, payload: updatedTask }, currentActor.id, 'author');
-        await Promise.all([
-            this.cycleStore.write(signedCycleRecord),
-            this.taskStore.write(signedTaskRecord)
-        ]);
-    }
-    // TODO: Implement when lint_command.md is implemented
-    async lint() {
-        throw new Error('NotImplementedError: lint() will be implemented when lint_command.md is ready');
-    }
-    // TODO: Implement when audit_command.md is implemented  
-    async audit() {
-        throw new Error('NotImplementedError: audit() will be implemented when audit_command.md is ready');
-    }
-    // TODO: Implement when commit_processor.md is implemented
-    async processChanges(_changes) {
-        throw new Error('NotImplementedError: processChanges() will be implemented when commit_processor.md is ready');
-    }
-}
-//# sourceMappingURL=index.js.map