macro-agent 0.1.1 → 0.1.3

package/dist/task/backend/sudocode/backend.js

@@ -1,942 +0,0 @@
-/**
- * SudocodeTaskBackend Implementation
- *
- * Implements TaskBackend using EventStore for local task storage and
- * SudocodeClient for external issue data and dependency tracking.
- *
- * @module task/backend/sudocode/backend
- * @see s-8472 Pluggable Task Backend Integration with Sudocode
- * @see i-2gwa 7A.5: Implement SudocodeTaskBackend core
- */
-import { nanoid } from "nanoid";
-import { mapSudocodeStatus, isIssueComplete } from "./mapping.js";
-import { createSyncPolicyEngine, } from "./sync-policy.js";
-// Valid status transitions
-const VALID_STATUS_TRANSITIONS = {
-    pending: ["assigned", "in_progress", "failed"],
-    assigned: ["in_progress", "pending", "failed"],
-    in_progress: ["completed", "failed", "pending"],
-    completed: [],
-    failed: ["pending"],
-};
-/**
- * Error thrown by SudocodeTaskBackend operations
- */
-export class SudocodeTaskBackendError extends Error {
-    code;
-    taskId;
-    constructor(message, code, taskId) {
-        super(message);
-        this.code = code;
-        this.taskId = taskId;
-        this.name = "SudocodeTaskBackendError";
-    }
-}
-const DEFAULT_CONFIG = {
-    projectPath: process.cwd(),
-    syncStatus: true,
-    autoCloseIssues: false,
-};
-/**
- * SudocodeTaskBackend implements TaskBackend using:
- * - EventStore for local task storage and events
- * - SudocodeClient for issue data and dependency tracking
- *
- * Key features:
- * - Tasks can be bound to sudocode issues via external_id
- * - isBlocked computed from sudocode's issue blockers
- * - listReady uses sudocode's ready issues API
- * - Status changes can optionally sync to issues
- */
-export class SudocodeTaskBackend {
-    eventStore;
-    client;
-    config;
-    tasksByIssue = new Map();
-    issueByTask = new Map();
-    syncEngine;
-    issueChangeUnsubscribe;
-    constructor(eventStore, client, config) {
-        this.eventStore = eventStore;
-        this.client = client;
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        this.syncEngine = createSyncPolicyEngine(config?.syncPolicy ?? {}, this);
-        this.rebuildIndex();
-        this.subscribeToIssueChanges();
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Index Management
-    // ─────────────────────────────────────────────────────────────────────────────
-    /**
-     * Rebuild the task-by-issue index from existing tasks
-     */
-    rebuildIndex() {
-        this.tasksByIssue.clear();
-        this.issueByTask.clear();
-        const tasks = this.eventStore.listTasks();
-        for (const task of tasks) {
-            const externalId = this.getTaskExternalId(task);
-            if (externalId) {
-                this.addToIndex(externalId, task.id);
-            }
-        }
-    }
-    /**
-     * Add a task to the issue index
-     */
-    addToIndex(issueId, taskId) {
-        // Update issue -> tasks map
-        if (!this.tasksByIssue.has(issueId)) {
-            this.tasksByIssue.set(issueId, new Set());
-        }
-        this.tasksByIssue.get(issueId).add(taskId);
-        // Update task -> issue map
-        this.issueByTask.set(taskId, issueId);
-    }
-    /**
-     * Remove a task from the issue index
-     */
-    removeFromIndex(issueId, taskId) {
-        // Update issue -> tasks map
-        const tasks = this.tasksByIssue.get(issueId);
-        if (tasks) {
-            tasks.delete(taskId);
-            if (tasks.size === 0) {
-                this.tasksByIssue.delete(issueId);
-            }
-        }
-        // Update task -> issue map
-        this.issueByTask.delete(taskId);
-    }
-    /**
-     * Get tasks bound to an issue
-     */
-    getTasksByIssue(issueId) {
-        return Array.from(this.tasksByIssue.get(issueId) ?? []);
-    }
-    /**
-     * Get the issue a task is bound to
-     */
-    getIssueForTask(taskId) {
-        return this.issueByTask.get(taskId);
-    }
-    /**
-     * Bind a task to a sudocode issue.
-     * @param taskId Task ID to bind
-     * @param issueId Issue ID to bind to
-     * @throws If task or issue not found
-     */
-    async bindToIssue(taskId, issueId) {
-        const task = this.eventStore.getTask(taskId);
-        if (!task) {
-            throw new SudocodeTaskBackendError(`Task not found: ${taskId}`, "TASK_NOT_FOUND", taskId);
-        }
-        // Verify issue exists
-        const issue = await this.client.getIssue(issueId);
-        if (!issue) {
-            throw new SudocodeTaskBackendError(`Issue not found: ${issueId}`, "ISSUE_NOT_FOUND");
-        }
-        // Check if already bound to a different issue
-        const currentIssue = this.getIssueForTask(taskId);
-        if (currentIssue && currentIssue !== issueId) {
-            // Remove from old index
-            this.removeFromIndex(currentIssue, taskId);
-        }
-        // Update task with external_id
-        this.eventStore.emit({
-            type: "task",
-            source: { agent_id: task.assigned_agent ?? task.created_by },
-            payload: {
-                task_id: taskId,
-                action: "status_change",
-                details: {
-                    outputs: { external_id: issueId },
-                },
-            },
-        });
-        // Update index
-        this.addToIndex(issueId, taskId);
-    }
-    /**
-     * Unbind a task from its current issue.
-     * @param taskId Task ID to unbind
-     * @throws If task not found
-     */
-    async unbindFromIssue(taskId) {
-        const task = this.eventStore.getTask(taskId);
-        if (!task) {
-            throw new SudocodeTaskBackendError(`Task not found: ${taskId}`, "TASK_NOT_FOUND", taskId);
-        }
-        const issueId = this.getIssueForTask(taskId);
-        if (!issueId) {
-            // Not bound, nothing to do
-            return;
-        }
-        // Clear external_id in task outputs
-        this.eventStore.emit({
-            type: "task",
-            source: { agent_id: task.assigned_agent ?? task.created_by },
-            payload: {
-                task_id: taskId,
-                action: "status_change",
-                details: {
-                    outputs: { external_id: null },
-                },
-            },
-        });
-        // Remove from index
-        this.removeFromIndex(issueId, taskId);
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Issue Change Subscription
-    // ─────────────────────────────────────────────────────────────────────────────
-    /**
-     * Subscribe to sudocode issue changes for status sync
-     */
-    subscribeToIssueChanges() {
-        if (!this.config.syncStatus)
-            return;
-        const callback = (event) => {
-            // Handle via sync policy engine
-            this.syncEngine.handleIssueChange(event).catch(() => {
-                // Ignore errors from sync engine
-            });
-            // Additionally handle status mapping for non-closed status changes
-            // (closed status is handled by the sync engine based on policy)
-            if (event.type === "status_changed" &&
-                event.issue &&
-                event.issue.status !== "closed") {
-                const taskIds = this.getTasksByIssue(event.issueId);
-                const newStatus = mapSudocodeStatus(event.issue.status);
-                for (const taskId of taskIds) {
-                    const task = this.eventStore.getTask(taskId);
-                    if (task && task.status !== newStatus) {
-                        // Only update if the task isn't in a terminal state
-                        // Also preserve "assigned" status - it's a macro-agent concept
-                        // that will transition to in_progress when start() is called
-                        if (task.status !== "completed" &&
-                            task.status !== "failed" &&
-                            task.status !== "assigned") {
-                            // Emit status change event
-                            this.eventStore.emit({
-                                type: "task",
-                                source: { agent_id: task.assigned_agent ?? task.created_by },
-                                payload: {
-                                    task_id: taskId,
-                                    action: "status_change",
-                                    details: { status: newStatus },
-                                },
-                            });
-                        }
-                    }
-                }
-            }
-        };
-        this.issueChangeUnsubscribe = this.client.onIssueChange(callback);
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Lifecycle
-    // ─────────────────────────────────────────────────────────────────────────────
-    async create(options) {
-        const taskId = `task_${nanoid(12)}`;
-        // Validate parent task exists if specified
-        if (options.parent_task) {
-            const parent = this.eventStore.getTask(options.parent_task);
-            if (!parent) {
-                throw new SudocodeTaskBackendError(`Parent task not found: ${options.parent_task}`, "PARENT_TASK_NOT_FOUND", options.parent_task);
-            }
-        }
-        // Validate external_id (issue) exists if specified
-        if (options.external_id) {
-            const issue = await this.client.getIssue(options.external_id);
-            if (!issue) {
-                throw new SudocodeTaskBackendError(`Issue not found: ${options.external_id}`, "ISSUE_NOT_FOUND");
-            }
-        }
-        // Emit task created event
-        this.eventStore.emit({
-            type: "task",
-            source: { agent_id: options.created_by },
-            payload: {
-                task_id: taskId,
-                action: "created",
-                details: {
-                    description: options.description,
-                    parent_task: options.parent_task,
-                    external_id: options.external_id,
-                },
-            },
-        });
-        // Update parent's subtasks array if this is a subtask
-        if (options.parent_task) {
-            this.eventStore.emit({
-                type: "task",
-                source: { agent_id: options.created_by },
-                payload: {
-                    task_id: options.parent_task,
-                    action: "status_change",
-                    details: {
-                        subtask_added: taskId,
-                    },
-                },
-            });
-        }
-        // Add to issue index if bound
-        if (options.external_id) {
-            this.addToIndex(options.external_id, taskId);
-        }
-        const task = this.eventStore.getTask(taskId);
-        return this.toExtendedTask(task);
-    }
-    async get(id) {
-        const task = this.eventStore.getTask(id);
-        if (!task)
-            return null;
-        return this.toExtendedTask(task);
-    }
-    async update(id, updates) {
-        const task = this.eventStore.getTask(id);
-        if (!task) {
-            throw new SudocodeTaskBackendError(`Task not found: ${id}`, "TASK_NOT_FOUND", id);
-        }
-        const source = task.assigned_agent ?? task.created_by;
-        // Handle status update with validation
-        if (updates.status !== undefined) {
-            const validTransitions = VALID_STATUS_TRANSITIONS[task.status];
-            if (!validTransitions.includes(updates.status)) {
-                throw new SudocodeTaskBackendError(`Invalid status transition: ${task.status} -> ${updates.status}`, "INVALID_STATUS_TRANSITION", id);
-            }
-            this.eventStore.emit({
-                type: "task",
-                source: { agent_id: source },
-                payload: {
-                    task_id: id,
-                    action: "status_change",
-                    details: { status: updates.status },
-                },
-            });
-        }
-        // Handle other updates
-        if (updates.outputs !== undefined) {
-            this.eventStore.emit({
-                type: "task",
-                source: { agent_id: source },
-                payload: {
-                    task_id: id,
-                    action: "status_change",
-                    details: { outputs: updates.outputs },
-                },
-            });
-        }
-        if (updates.artifacts !== undefined) {
-            this.eventStore.emit({
-                type: "task",
-                source: { agent_id: source },
-                payload: {
-                    task_id: id,
-                    action: "status_change",
-                    details: { artifacts: updates.artifacts },
-                },
-            });
-        }
-        if (updates.description !== undefined) {
-            this.eventStore.emit({
-                type: "task",
-                source: { agent_id: source },
-                payload: {
-                    task_id: id,
-                    action: "status_change",
-                    details: { description: updates.description },
-                },
-            });
-        }
-        const updated = this.eventStore.getTask(id);
-        return this.toExtendedTask(updated);
-    }
-    async delete(_id) {
-        // Tasks are immutable in event-sourced system - no delete operation
-        // This matches InMemoryTaskBackend behavior for backend parity
-        throw new SudocodeTaskBackendError("Delete operation not supported - tasks are immutable", "NOT_SUPPORTED");
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Status Transitions
-    // ─────────────────────────────────────────────────────────────────────────────
-    async assign(id, agentId, options) {
-        const task = this.eventStore.getTask(id);
-        if (!task) {
-            throw new SudocodeTaskBackendError(`Task not found: ${id}`, "TASK_NOT_FOUND", id);
-        }
-        this.eventStore.emit({
-            type: "task",
-            source: { agent_id: agentId },
-            payload: {
-                task_id: id,
-                action: "assigned",
-                details: {
-                    agent_id: agentId,
-                    role: options?.role,
-                },
-            },
-        });
-        // Note: We don't sync to sudocode on assign because "assigned" is a
-        // macro-agent concept (task has a worker but work hasn't started).
-        // Sudocode "in_progress" is synced when start() is called.
-    }
-    async unassign(id) {
-        const task = this.eventStore.getTask(id);
-        if (!task) {
-            throw new SudocodeTaskBackendError(`Task not found: ${id}`, "TASK_NOT_FOUND", id);
-        }
-        if (!task.assigned_agent) {
-            throw new SudocodeTaskBackendError(`Task is not assigned: ${id}`, "TASK_NOT_ASSIGNED", id);
-        }
-        this.eventStore.emit({
-            type: "task",
-            source: { agent_id: task.assigned_agent },
-            payload: {
-                task_id: id,
-                action: "unassigned",
-                details: {
-                    agent_id: task.assigned_agent,
-                },
-            },
-        });
-    }
-    async start(id) {
-        const task = this.eventStore.getTask(id);
-        if (!task) {
-            throw new SudocodeTaskBackendError(`Task not found: ${id}`, "TASK_NOT_FOUND", id);
-        }
-        const validTransitions = VALID_STATUS_TRANSITIONS[task.status];
-        if (!validTransitions.includes("in_progress")) {
-            throw new SudocodeTaskBackendError(`Invalid status transition: ${task.status} -> in_progress`, "INVALID_STATUS_TRANSITION", id);
-        }
-        this.eventStore.emit({
-            type: "task",
-            source: { agent_id: task.assigned_agent ?? task.created_by },
-            payload: {
-                task_id: id,
-                action: "status_change",
-                details: { status: "in_progress" },
-            },
-        });
-        // Update issue status
-        const externalId = this.getTaskExternalId(task);
-        if (externalId && this.config.syncStatus) {
-            try {
-                await this.client.updateIssue(externalId, { status: "in_progress" });
-            }
-            catch {
-                // Ignore errors syncing to sudocode
-            }
-        }
-    }
-    async complete(id, outputs) {
-        const task = this.eventStore.getTask(id);
-        if (!task) {
-            throw new SudocodeTaskBackendError(`Task not found: ${id}`, "TASK_NOT_FOUND", id);
-        }
-        const validTransitions = VALID_STATUS_TRANSITIONS[task.status];
-        if (!validTransitions.includes("completed")) {
-            throw new SudocodeTaskBackendError(`Invalid status transition: ${task.status} -> completed`, "INVALID_STATUS_TRANSITION", id);
-        }
-        // Add outputs if provided
-        if (outputs) {
-            if (outputs.data) {
-                this.eventStore.emit({
-                    type: "task",
-                    source: { agent_id: task.assigned_agent ?? task.created_by },
-                    payload: {
-                        task_id: id,
-                        action: "status_change",
-                        details: { outputs: outputs.data },
-                    },
-                });
-            }
-            if (outputs.artifacts) {
-                this.eventStore.emit({
-                    type: "task",
-                    source: { agent_id: task.assigned_agent ?? task.created_by },
-                    payload: {
-                        task_id: id,
-                        action: "status_change",
-                        details: { artifacts: outputs.artifacts },
-                    },
-                });
-            }
-        }
-        this.eventStore.emit({
-            type: "task",
-            source: { agent_id: task.assigned_agent ?? task.created_by },
-            payload: {
-                task_id: id,
-                action: "completed",
-                details: {},
-            },
-        });
-        // Optionally close the issue
-        const externalId = this.getTaskExternalId(task);
-        if (externalId && this.config.autoCloseIssues) {
-            try {
-                await this.client.updateIssue(externalId, { status: "closed" });
-            }
-            catch {
-                // Ignore errors syncing to sudocode
-            }
-        }
-    }
-    async fail(id, error) {
-        const task = this.eventStore.getTask(id);
-        if (!task) {
-            throw new SudocodeTaskBackendError(`Task not found: ${id}`, "TASK_NOT_FOUND", id);
-        }
-        const validTransitions = VALID_STATUS_TRANSITIONS[task.status];
-        if (!validTransitions.includes("failed")) {
-            throw new SudocodeTaskBackendError(`Invalid status transition: ${task.status} -> failed`, "INVALID_STATUS_TRANSITION", id);
-        }
-        // Store error info in outputs
-        this.eventStore.emit({
-            type: "task",
-            source: { agent_id: task.assigned_agent ?? task.created_by },
-            payload: {
-                task_id: id,
-                action: "status_change",
-                details: {
-                    outputs: {
-                        error: {
-                            message: error.message,
-                            code: error.code,
-                            details: error.details,
-                        },
-                    },
-                },
-            },
-        });
-        this.eventStore.emit({
-            type: "task",
-            source: { agent_id: task.assigned_agent ?? task.created_by },
-            payload: {
-                task_id: id,
-                action: "failed",
-                details: {},
-            },
-        });
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Queries
-    // ─────────────────────────────────────────────────────────────────────────────
-    async list(filter) {
-        let tasks = this.eventStore.listTasks();
-        if (filter) {
-            // Filter by status
-            if (filter.status) {
-                const statuses = Array.isArray(filter.status)
-                    ? filter.status
-                    : [filter.status];
-                tasks = tasks.filter((t) => statuses.includes(t.status));
-            }
-            if (filter.assigned_agent) {
-                tasks = tasks.filter((t) => t.assigned_agent === filter.assigned_agent);
-            }
-            if (filter.parent_task) {
-                tasks = tasks.filter((t) => t.parent_task === filter.parent_task);
-            }
-            if (filter.created_by) {
-                tasks = tasks.filter((t) => t.created_by === filter.created_by);
-            }
-            if (filter.rootTasksOnly) {
-                tasks = tasks.filter((t) => !t.parent_task);
-            }
-        }
-        // Convert to ExtendedTask (async because of issue lookups)
-        const extended = await Promise.all(tasks.map((t) => this.toExtendedTask(t)));
-        // Filter blocked if needed
-        if (!filter?.includeBlocked) {
-            return extended.filter((t) => !t.isBlocked);
-        }
-        return extended;
-    }
-    async listReady(filter) {
-        // Get pending/assigned tasks with isBlocked computed
-        const tasks = await this.list({
-            ...filter,
-            status: filter?.status ?? ["pending", "assigned"],
-            includeBlocked: true, // We'll filter manually
-        });
-        // Filter to ready tasks
-        // isBlocked already checks both local and sudocode blockers,
-        // respecting local task completion over stale sudocode state.
-        const readyTasks = [];
-        for (const task of tasks) {
-            if (task.isBlocked) {
-                continue;
-            }
-            // For bound tasks, also check issue status directly
-            // (excludes tasks bound to issues with "blocked" status)
-            if (task.external_id) {
-                try {
-                    const issue = await this.client.getIssue(task.external_id);
-                    if (issue && issue.status === "blocked") {
-                        continue;
-                    }
-                }
-                catch {
-                    // If we can't fetch issue, include the task
-                }
-            }
-            readyTasks.push(task);
-        }
-        return readyTasks;
-    }
-    async getChildren(parentId) {
-        const tasks = this.eventStore.listTasks();
-        const children = tasks.filter((t) => t.parent_task === parentId);
-        return Promise.all(children.map((t) => this.toExtendedTask(t)));
-    }
-    async getSubtaskStatus(parentId) {
-        const children = await this.getChildren(parentId);
-        const status = {
-            total: children.length,
-            pending: 0,
-            assigned: 0,
-            in_progress: 0,
-            completed: 0,
-            failed: 0,
-            allCompleted: false,
-            anyFailed: false,
-        };
-        for (const task of children) {
-            switch (task.status) {
-                case "pending":
-                    status.pending++;
-                    break;
-                case "assigned":
-                    status.assigned++;
-                    break;
-                case "in_progress":
-                    status.in_progress++;
-                    break;
-                case "completed":
-                    status.completed++;
-                    break;
-                case "failed":
-                    status.failed++;
-                    break;
-            }
-        }
-        status.allCompleted =
-            status.total > 0 && status.completed === status.total;
-        status.anyFailed = status.failed > 0;
-        return status;
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Hierarchy
-    // ─────────────────────────────────────────────────────────────────────────────
-    async createSubtask(parentId, options) {
-        return this.create({
-            ...options,
-            parent_task: parentId,
-        });
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Dependencies
-    // ─────────────────────────────────────────────────────────────────────────────
-    async addBlocker(taskId, blockerId) {
-        const task = this.eventStore.getTask(taskId);
-        if (!task) {
-            throw new SudocodeTaskBackendError(`Task not found: ${taskId}`, "TASK_NOT_FOUND", taskId);
-        }
-        const blocker = this.eventStore.getTask(blockerId);
-        if (!blocker) {
-            throw new SudocodeTaskBackendError(`Blocker task not found: ${blockerId}`, "TASK_NOT_FOUND", blockerId);
-        }
-        // Always track locally via EventStore
-        this.eventStore.emit({
-            type: "task",
-            source: { agent_id: task.assigned_agent ?? task.created_by },
-            payload: {
-                task_id: taskId,
-                action: "blocker_added",
-                details: { blocker_id: blockerId },
-            },
-        });
-        // If both tasks are bound to sudocode issues, create a sudocode relationship
-        const taskIssueId = this.getIssueForTask(taskId);
-        const blockerIssueId = this.getIssueForTask(blockerId);
-        if (taskIssueId && blockerIssueId) {
-            try {
-                // In sudocode, "A blocks B" means A must complete before B
-                // So we create: blockerIssue blocks taskIssue
-                await this.client.createLink(blockerIssueId, taskIssueId, "blocks");
-            }
-            catch {
-                // Log but don't fail - local tracking is the source of truth
-            }
-        }
-    }
-    async removeBlocker(taskId, blockerId) {
-        const task = this.eventStore.getTask(taskId);
-        if (!task) {
-            throw new SudocodeTaskBackendError(`Task not found: ${taskId}`, "TASK_NOT_FOUND", taskId);
-        }
-        // Always update local EventStore tracking
-        this.eventStore.emit({
-            type: "task",
-            source: { agent_id: task.assigned_agent ?? task.created_by },
-            payload: {
-                task_id: taskId,
-                action: "blocker_removed",
-                details: { blocker_id: blockerId },
-            },
-        });
-        // If both tasks are bound to sudocode issues, remove the sudocode relationship
-        const taskIssueId = this.getIssueForTask(taskId);
-        const blockerIssueId = this.getIssueForTask(blockerId);
-        if (taskIssueId && blockerIssueId) {
-            try {
-                await this.client.removeLink(blockerIssueId, taskIssueId, "blocks");
-            }
-            catch {
-                // Log but don't fail - local tracking is the source of truth
-            }
-        }
-    }
-    async getBlockers(taskId) {
-        const task = this.eventStore.getTask(taskId);
-        if (!task) {
-            throw new SudocodeTaskBackendError(`Task not found: ${taskId}`, "TASK_NOT_FOUND", taskId);
-        }
-        // Track blockers by ID to avoid duplicates
-        const blockerMap = new Map();
-        // Get local task blockers
-        const localBlockerIds = task.blockers ?? [];
-        for (const blockerId of localBlockerIds) {
-            const blocker = this.eventStore.getTask(blockerId);
-            if (blocker && !blockerMap.has(blockerId)) {
-                blockerMap.set(blockerId, await this.toExtendedTask(blocker));
-            }
-        }
-        // If task is bound to an issue, also get sudocode blockers
-        const taskIssueId = this.getIssueForTask(taskId);
-        if (taskIssueId) {
-            try {
-                const issueBlockers = await this.client.getBlockers(taskIssueId);
-                for (const issueBlocker of issueBlockers) {
-                    // Find tasks bound to this blocking issue
-                    const blockerTaskIds = this.getTasksByIssue(issueBlocker.id);
-                    for (const blockerTaskId of blockerTaskIds) {
-                        if (!blockerMap.has(blockerTaskId)) {
-                            const blockerTask = this.eventStore.getTask(blockerTaskId);
-                            if (blockerTask) {
-                                blockerMap.set(blockerTaskId, await this.toExtendedTask(blockerTask));
-                            }
-                        }
-                    }
-                }
-            }
-            catch {
-                // Ignore errors fetching sudocode blockers - local is source of truth
-            }
-        }
-        return Array.from(blockerMap.values());
-    }
-    async getBlocking(taskId) {
-        const task = this.eventStore.getTask(taskId);
-        if (!task) {
-            throw new SudocodeTaskBackendError(`Task not found: ${taskId}`, "TASK_NOT_FOUND", taskId);
-        }
-        // Track blocked tasks by ID to avoid duplicates
-        const blockingMap = new Map();
-        // Find all local tasks that have this task in their blockers
-        const allTasks = this.eventStore.listTasks();
-        const localBlocking = allTasks.filter((t) => t.blockers?.includes(taskId));
-        for (const blockedTask of localBlocking) {
-            if (!blockingMap.has(blockedTask.id)) {
-                blockingMap.set(blockedTask.id, await this.toExtendedTask(blockedTask));
-            }
-        }
-        // If task is bound to an issue, also get sudocode blocking
-        const taskIssueId = this.getIssueForTask(taskId);
-        if (taskIssueId) {
-            try {
-                const issueBlocking = await this.client.getBlocking(taskIssueId);
-                for (const blockedIssue of issueBlocking) {
-                    // Find tasks bound to this blocked issue
-                    const blockedTaskIds = this.getTasksByIssue(blockedIssue.id);
-                    for (const blockedTaskId of blockedTaskIds) {
-                        if (!blockingMap.has(blockedTaskId)) {
-                            const blockedTask = this.eventStore.getTask(blockedTaskId);
-                            if (blockedTask) {
-                                blockingMap.set(blockedTaskId, await this.toExtendedTask(blockedTask));
-                            }
-                        }
-                    }
-                }
-            }
-            catch {
-                // Ignore errors fetching sudocode blocking - local is source of truth
-            }
-        }
-        return Array.from(blockingMap.values());
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // History
-    // ─────────────────────────────────────────────────────────────────────────────
-    async getAgentHistory(taskId) {
-        const task = this.eventStore.getTask(taskId);
-        if (!task) {
-            throw new SudocodeTaskBackendError(`Task not found: ${taskId}`, "TASK_NOT_FOUND", taskId);
-        }
-        return task.agent_history ?? [];
-    }
-    onTaskChange(callbackOrTaskId, maybeCallback) {
-        const filterTaskId = typeof callbackOrTaskId === "string" ? callbackOrTaskId : undefined;
-        const callback = typeof callbackOrTaskId === "function"
-            ? callbackOrTaskId
-            : maybeCallback;
-        // Wrap EventStore's onTaskChange
-        return this.eventStore.onTaskChange((taskId, task) => {
-            if (filterTaskId && taskId !== filterTaskId) {
-                return;
-            }
-            // Build TaskChangeEvent using sync conversion (checks local blockers only)
-            const event = {
-                type: task ? "updated" : "deleted",
-                taskId,
-                task: task ? this.toExtendedTaskSync(task) : {},
-            };
-            callback(event);
-        });
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Sync Policy
-    // ─────────────────────────────────────────────────────────────────────────────
-    /**
-     * Get the current sync policy
-     */
-    getSyncPolicy() {
-        return this.syncEngine.getPolicy();
-    }
-    /**
-     * Subscribe to sync events from the policy engine
-     */
-    onSyncEvent(callback) {
-        return this.syncEngine.onSyncEvent(callback);
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Cleanup
-    // ─────────────────────────────────────────────────────────────────────────────
-    /**
-     * Close the backend and release resources
-     */
-    close() {
-        if (this.issueChangeUnsubscribe) {
-            this.issueChangeUnsubscribe();
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Private Helpers
-    // ─────────────────────────────────────────────────────────────────────────────
-    /**
-     * Get the external_id from a task (if stored in outputs)
-     */
-    getTaskExternalId(task) {
-        // First check in-memory index (populated during create and rebuildIndex)
-        const fromIndex = this.issueByTask.get(task.id);
-        if (fromIndex) {
-            return fromIndex;
-        }
-        // Fall back to checking outputs (for persistence after restart via bindToIssue)
-        const outputs = task.outputs;
-        if (outputs?.external_id && typeof outputs.external_id === "string") {
-            return outputs.external_id;
-        }
-        return undefined;
-    }
-    /**
-     * Convert a Task to ExtendedTask with computed isBlocked field.
-     * Checks both local blockers and sudocode issue blockers.
-     *
-     * For sudocode issue blockers, a blocker is considered resolved if:
-     * 1. The issue itself is closed/completed, OR
-     * 2. Any local task bound to that issue is completed (local takes precedence)
-     */
-    async toExtendedTask(task) {
-        let isBlocked = false;
-        // Check local blockers first
-        const localBlockerIds = task.blockers ?? [];
-        for (const blockerId of localBlockerIds) {
-            const blocker = this.eventStore.getTask(blockerId);
-            if (blocker && blocker.status !== "completed") {
-                isBlocked = true;
-                break;
-            }
-        }
-        // Check sudocode issue blockers if task is bound
-        if (!isBlocked) {
-            const externalId = this.getTaskExternalId(task);
-            if (externalId) {
-                try {
-                    const issueBlockers = await this.client.getBlockers(externalId);
-                    for (const blocker of issueBlockers) {
-                        // Check if any local task bound to this blocking issue is completed
-                        // Local task completion takes precedence over issue status
-                        const localTasksForBlocker = this.getTasksByIssue(blocker.id);
-                        const hasCompletedLocalTask = localTasksForBlocker.some((taskId) => {
-                            const blockerTask = this.eventStore.getTask(taskId);
-                            return blockerTask && blockerTask.status === "completed";
-                        });
-                        // Blocker is unresolved if:
-                        // - No local task is completed for this issue, AND
-                        // - The issue itself is not complete
-                        if (!hasCompletedLocalTask && !isIssueComplete(blocker.status)) {
-                            isBlocked = true;
-                            break;
-                        }
-                    }
-                }
-                catch {
-                    // If we can't fetch blockers, assume not blocked
-                }
-            }
-        }
-        return {
-            ...task,
-            isBlocked,
-            external_id: this.getTaskExternalId(task),
-        };
-    }
-    /**
-     * Synchronous version of toExtendedTask that only checks local blockers.
-     * Used in callbacks where async is not possible.
-     * Note: Does not check sudocode issue blockers - only local task blockers.
-     */
-    toExtendedTaskSync(task) {
-        let isBlocked = false;
-        // Check local blockers only (sync operation)
-        const localBlockerIds = task.blockers ?? [];
-        for (const blockerId of localBlockerIds) {
-            const blocker = this.eventStore.getTask(blockerId);
-            if (blocker && blocker.status !== "completed") {
-                isBlocked = true;
-                break;
-            }
-        }
-        return {
-            ...task,
-            isBlocked,
-            external_id: this.getTaskExternalId(task),
-        };
-    }
-}
-/**
- * Create a SudocodeTaskBackend instance.
- *
- * @param eventStore - EventStore for local task storage
- * @param client - SudocodeClient for issue access
- * @param config - Optional configuration
- */
-export function createSudocodeTaskBackend(eventStore, client, config) {
-    return new SudocodeTaskBackend(eventStore, client, config);
-}
-//# sourceMappingURL=backend.js.map