@gitgov/core 1.0.0

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

@@ -0,0 +1,924 @@
+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