lockstep-mcp 0.1.0

package/dist/storage.js

@@ -0,0 +1,1235 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+import Database from "better-sqlite3";
+import { ensureDir, sleep } from "./utils.js";
+function nowIso() {
+    return new Date().toISOString();
+}
+async function appendLog(logDir, event, payload) {
+    const logPath = path.join(logDir, "events.jsonl");
+    const line = JSON.stringify({ ts: nowIso(), event, ...payload });
+    await fs.appendFile(logPath, `${line}\n`, "utf8");
+}
+const DEFAULT_STATE = {
+    tasks: [],
+    locks: [],
+    notes: [],
+};
+export class JsonStore {
+    dataDir;
+    logDir;
+    statePath;
+    lockPath;
+    contextPath;
+    constructor(dataDir, logDir) {
+        this.dataDir = dataDir;
+        this.logDir = logDir;
+        this.statePath = path.join(this.dataDir, "state.json");
+        this.lockPath = path.join(this.dataDir, "state.lock");
+        this.contextPath = path.join(this.dataDir, "project_contexts.json");
+    }
+    async init() {
+        await ensureDir(this.dataDir);
+        await ensureDir(this.logDir);
+    }
+    async loadState() {
+        try {
+            const raw = await fs.readFile(this.statePath, "utf8");
+            return { ...DEFAULT_STATE, ...JSON.parse(raw) };
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === "ENOENT")
+                return { ...DEFAULT_STATE };
+            throw error;
+        }
+    }
+    async saveState(state) {
+        await fs.writeFile(this.statePath, JSON.stringify(state, null, 2), "utf8");
+    }
+    async withStateLock(fn) {
+        const start = Date.now();
+        const timeoutMs = 5000;
+        while (true) {
+            try {
+                const handle = await fs.open(this.lockPath, "wx");
+                await handle.close();
+                break;
+            }
+            catch (error) {
+                const err = error;
+                if (err.code !== "EEXIST")
+                    throw error;
+                if (Date.now() - start > timeoutMs) {
+                    throw new Error("Timed out waiting for state lock");
+                }
+                await sleep(50);
+            }
+        }
+        try {
+            return await fn();
+        }
+        finally {
+            await fs.unlink(this.lockPath).catch(() => undefined);
+        }
+    }
+    async status() {
+        return this.loadState();
+    }
+    async createTask(input) {
+        return this.withStateLock(async () => {
+            const state = await this.loadState();
+            const task = {
+                id: crypto.randomUUID(),
+                title: input.title,
+                description: input.description,
+                status: input.status ?? "todo",
+                complexity: input.complexity ?? "medium",
+                isolation: input.isolation ?? "shared",
+                owner: input.owner,
+                tags: input.tags,
+                metadata: input.metadata,
+                createdAt: nowIso(),
+                updatedAt: nowIso(),
+            };
+            state.tasks.push(task);
+            await this.saveState(state);
+            await appendLog(this.logDir, "task_create", { task });
+            return task;
+        });
+    }
+    async updateTask(input) {
+        return this.withStateLock(async () => {
+            const state = await this.loadState();
+            const task = state.tasks.find((item) => item.id === input.id);
+            if (!task)
+                throw new Error(`Task not found: ${input.id}`);
+            if (input.title !== undefined)
+                task.title = input.title;
+            if (input.description !== undefined)
+                task.description = input.description;
+            if (input.status !== undefined)
+                task.status = input.status;
+            if (input.owner !== undefined)
+                task.owner = input.owner;
+            if (input.tags !== undefined)
+                task.tags = input.tags;
+            if (input.metadata !== undefined)
+                task.metadata = input.metadata;
+            task.updatedAt = nowIso();
+            await this.saveState(state);
+            await appendLog(this.logDir, "task_update", { task });
+            return task;
+        });
+    }
+    async claimTask(input) {
+        return this.updateTask({ id: input.id, owner: input.owner, status: "in_progress" });
+    }
+    // Review workflow methods - not fully implemented for JSON storage
+    async submitTaskForReview() {
+        throw new Error("Review workflow requires SQLite storage. Set storage: 'sqlite' in config.");
+    }
+    async approveTask() {
+        throw new Error("Review workflow requires SQLite storage.");
+    }
+    async requestTaskChanges() {
+        throw new Error("Review workflow requires SQLite storage.");
+    }
+    async listTasks(filters) {
+        const state = await this.loadState();
+        let tasks = [...state.tasks];
+        if (filters?.status)
+            tasks = tasks.filter((task) => task.status === filters.status);
+        if (filters?.owner)
+            tasks = tasks.filter((task) => task.owner === filters.owner);
+        if (filters?.tag)
+            tasks = tasks.filter((task) => task.tags?.includes(filters.tag ?? ""));
+        if (filters?.limit && filters.limit > 0)
+            tasks = tasks.slice(0, filters.limit);
+        return tasks;
+    }
+    async acquireLock(input) {
+        return this.withStateLock(async () => {
+            const state = await this.loadState();
+            const existing = state.locks.find((lock) => lock.path === input.path && lock.status === "active");
+            if (existing)
+                throw new Error(`Lock already active for ${input.path}`);
+            const lock = {
+                path: input.path,
+                owner: input.owner,
+                note: input.note,
+                status: "active",
+                createdAt: nowIso(),
+                updatedAt: nowIso(),
+            };
+            state.locks.push(lock);
+            await this.saveState(state);
+            await appendLog(this.logDir, "lock_acquire", { lock });
+            return lock;
+        });
+    }
+    async releaseLock(input) {
+        return this.withStateLock(async () => {
+            const state = await this.loadState();
+            const lock = state.locks.find((item) => item.path === input.path && item.status === "active");
+            if (!lock)
+                throw new Error(`Active lock not found for ${input.path}`);
+            if (input.owner && lock.owner && input.owner !== lock.owner) {
+                throw new Error(`Lock owned by ${lock.owner}, not ${input.owner}`);
+            }
+            lock.status = "resolved";
+            lock.updatedAt = nowIso();
+            await this.saveState(state);
+            await appendLog(this.logDir, "lock_release", { lock });
+            return lock;
+        });
+    }
+    async listLocks(filters) {
+        const state = await this.loadState();
+        let locks = [...state.locks];
+        if (filters?.status)
+            locks = locks.filter((lock) => lock.status === filters.status);
+        if (filters?.owner)
+            locks = locks.filter((lock) => lock.owner === filters.owner);
+        return locks;
+    }
+    async appendNote(input) {
+        return this.withStateLock(async () => {
+            const state = await this.loadState();
+            const note = {
+                id: crypto.randomUUID(),
+                text: input.text,
+                author: input.author,
+                createdAt: nowIso(),
+            };
+            state.notes.push(note);
+            await this.saveState(state);
+            await appendLog(this.logDir, "note_append", { note });
+            return note;
+        });
+    }
+    async listNotes(limit) {
+        const state = await this.loadState();
+        if (!limit || limit <= 0)
+            return [...state.notes];
+        return state.notes.slice(Math.max(state.notes.length - limit, 0));
+    }
+    async appendLogEntry(event, payload) {
+        await appendLog(this.logDir, event, payload ?? {});
+    }
+    async loadContexts() {
+        try {
+            const raw = await fs.readFile(this.contextPath, "utf8");
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === "ENOENT")
+                return {};
+            throw error;
+        }
+    }
+    async saveContexts(contexts) {
+        await fs.writeFile(this.contextPath, JSON.stringify(contexts, null, 2), "utf8");
+    }
+    async setProjectContext(input) {
+        return this.withStateLock(async () => {
+            const contexts = await this.loadContexts();
+            const existing = contexts[input.projectRoot];
+            const context = {
+                projectRoot: input.projectRoot,
+                description: input.description,
+                endState: input.endState,
+                techStack: input.techStack,
+                constraints: input.constraints,
+                acceptanceCriteria: input.acceptanceCriteria,
+                tests: input.tests,
+                implementationPlan: input.implementationPlan,
+                preferredImplementer: input.preferredImplementer ?? existing?.preferredImplementer,
+                status: input.status ?? existing?.status ?? "planning",
+                createdAt: existing?.createdAt ?? nowIso(),
+                updatedAt: nowIso(),
+            };
+            contexts[input.projectRoot] = context;
+            await this.saveContexts(contexts);
+            await appendLog(this.logDir, "project_context_set", { context });
+            return context;
+        });
+    }
+    async getProjectContext(projectRoot) {
+        const contexts = await this.loadContexts();
+        return contexts[projectRoot] ?? null;
+    }
+    async listAllProjectContexts() {
+        const contexts = await this.loadContexts();
+        return Object.values(contexts);
+    }
+    async updateProjectStatus(projectRoot, status) {
+        return this.withStateLock(async () => {
+            const contexts = await this.loadContexts();
+            const existing = contexts[projectRoot];
+            if (!existing)
+                throw new Error(`Project context not found: ${projectRoot}`);
+            existing.status = status;
+            existing.updatedAt = nowIso();
+            await this.saveContexts(contexts);
+            await appendLog(this.logDir, "project_status_update", { projectRoot, status });
+            return existing;
+        });
+    }
+    get implementersPath() {
+        return path.join(this.dataDir, "implementers.json");
+    }
+    async loadImplementers() {
+        try {
+            const raw = await fs.readFile(this.implementersPath, "utf8");
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === "ENOENT")
+                return {};
+            throw error;
+        }
+    }
+    async saveImplementers(implementers) {
+        await fs.writeFile(this.implementersPath, JSON.stringify(implementers, null, 2), "utf8");
+    }
+    async registerImplementer(input) {
+        return this.withStateLock(async () => {
+            const implementers = await this.loadImplementers();
+            const implementer = {
+                id: crypto.randomUUID(),
+                name: input.name,
+                type: input.type,
+                projectRoot: input.projectRoot,
+                status: "active",
+                pid: input.pid,
+                isolation: input.isolation ?? "shared",
+                worktreePath: input.worktreePath,
+                branchName: input.branchName,
+                createdAt: nowIso(),
+                updatedAt: nowIso(),
+            };
+            implementers[implementer.id] = implementer;
+            await this.saveImplementers(implementers);
+            await appendLog(this.logDir, "implementer_register", { implementer });
+            return implementer;
+        });
+    }
+    async updateImplementer(id, status) {
+        return this.withStateLock(async () => {
+            const implementers = await this.loadImplementers();
+            const implementer = implementers[id];
+            if (!implementer)
+                throw new Error(`Implementer not found: ${id}`);
+            implementer.status = status;
+            implementer.updatedAt = nowIso();
+            await this.saveImplementers(implementers);
+            await appendLog(this.logDir, "implementer_update", { implementer });
+            return implementer;
+        });
+    }
+    async listImplementers(projectRoot) {
+        const implementers = await this.loadImplementers();
+        let list = Object.values(implementers);
+        if (projectRoot) {
+            list = list.filter((impl) => impl.projectRoot === projectRoot);
+        }
+        return list;
+    }
+    async resetImplementers(projectRoot) {
+        return this.withStateLock(async () => {
+            const implementers = await this.loadImplementers();
+            let count = 0;
+            for (const id of Object.keys(implementers)) {
+                const impl = implementers[id];
+                if (impl.projectRoot === projectRoot && impl.status === "active") {
+                    impl.status = "stopped";
+                    impl.updatedAt = nowIso();
+                    count++;
+                }
+            }
+            await this.saveImplementers(implementers);
+            await appendLog(this.logDir, "implementers_reset", { projectRoot, count });
+            return count;
+        });
+    }
+    async resetSession(projectRoot, options) {
+        return this.withStateLock(async () => {
+            const state = await this.loadState();
+            // Count and clear tasks
+            const tasksCleared = state.tasks.length;
+            state.tasks = [];
+            // Count and clear locks
+            const locksCleared = state.locks.length;
+            state.locks = [];
+            // Count and clear notes
+            const notesCleared = state.notes.length;
+            state.notes = [];
+            await this.saveState(state);
+            // Reset implementers
+            const implementersReset = await this.resetImplementers(projectRoot);
+            // Clear project context unless keepProjectContext is true
+            if (!options?.keepProjectContext) {
+                const contexts = await this.loadContexts();
+                delete contexts[projectRoot];
+                await this.saveContexts(contexts);
+            }
+            await appendLog(this.logDir, "session_reset", {
+                projectRoot,
+                tasksCleared,
+                locksCleared,
+                notesCleared,
+                implementersReset,
+                discussionsArchived: 0
+            });
+            return {
+                tasksCleared,
+                locksCleared,
+                notesCleared,
+                implementersReset,
+                discussionsArchived: 0 // JSON store doesn't support discussions
+            };
+        });
+    }
+    // Discussion methods - not implemented for JSON storage (use SQLite)
+    async createDiscussion() {
+        throw new Error("Discussion features require SQLite storage. Set storage: 'sqlite' in config.");
+    }
+    async replyToDiscussion() {
+        throw new Error("Discussion features require SQLite storage.");
+    }
+    async resolveDiscussion() {
+        throw new Error("Discussion features require SQLite storage.");
+    }
+    async getDiscussion() {
+        throw new Error("Discussion features require SQLite storage.");
+    }
+    async listDiscussions() {
+        throw new Error("Discussion features require SQLite storage.");
+    }
+    async archiveDiscussion() {
+        throw new Error("Discussion features require SQLite storage.");
+    }
+    async archiveOldDiscussions() {
+        throw new Error("Discussion features require SQLite storage.");
+    }
+    async deleteArchivedDiscussions() {
+        throw new Error("Discussion features require SQLite storage.");
+    }
+}
+export class SqliteStore {
+    dbPath;
+    logDir;
+    db;
+    constructor(dbPath, logDir) {
+        this.dbPath = dbPath;
+        this.logDir = logDir;
+    }
+    async init() {
+        await ensureDir(path.dirname(this.dbPath));
+        await ensureDir(this.logDir);
+        this.db = new Database(this.dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        description TEXT,
+        status TEXT NOT NULL,
+        complexity TEXT NOT NULL DEFAULT 'medium',
+        isolation TEXT NOT NULL DEFAULT 'shared',
+        owner TEXT,
+        tags TEXT,
+        metadata TEXT,
+        review_notes TEXT,
+        review_feedback TEXT,
+        review_requested_at TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS locks (
+        path TEXT PRIMARY KEY,
+        owner TEXT,
+        note TEXT,
+        status TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS notes (
+        id TEXT PRIMARY KEY,
+        text TEXT NOT NULL,
+        author TEXT,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS project_contexts (
+        project_root TEXT PRIMARY KEY,
+        description TEXT NOT NULL,
+        end_state TEXT NOT NULL,
+        tech_stack TEXT,
+        constraints TEXT,
+        acceptance_criteria TEXT,
+        tests TEXT,
+        implementation_plan TEXT,
+        status TEXT NOT NULL DEFAULT 'planning',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS implementers (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        type TEXT NOT NULL,
+        project_root TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'active',
+        pid INTEGER,
+        isolation TEXT NOT NULL DEFAULT 'shared',
+        worktree_path TEXT,
+        branch_name TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS discussions (
+        id TEXT PRIMARY KEY,
+        topic TEXT NOT NULL,
+        category TEXT NOT NULL DEFAULT 'other',
+        priority TEXT NOT NULL DEFAULT 'medium',
+        status TEXT NOT NULL DEFAULT 'open',
+        project_root TEXT NOT NULL,
+        created_by TEXT NOT NULL,
+        waiting_on TEXT,
+        decision TEXT,
+        decision_reasoning TEXT,
+        decided_by TEXT,
+        linked_task_id TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        resolved_at TEXT,
+        archived_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS discussion_messages (
+        id TEXT PRIMARY KEY,
+        discussion_id TEXT NOT NULL,
+        author TEXT NOT NULL,
+        message TEXT NOT NULL,
+        recommendation TEXT,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (discussion_id) REFERENCES discussions(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_discussions_status ON discussions(status);
+      CREATE INDEX IF NOT EXISTS idx_discussions_project ON discussions(project_root);
+      CREATE INDEX IF NOT EXISTS idx_discussion_messages_discussion ON discussion_messages(discussion_id);
+    `);
+        // Migration: add new columns if they don't exist
+        try {
+            this.db.exec("ALTER TABLE project_contexts ADD COLUMN acceptance_criteria TEXT");
+        }
+        catch { /* column exists */ }
+        try {
+            this.db.exec("ALTER TABLE project_contexts ADD COLUMN tests TEXT");
+        }
+        catch { /* column exists */ }
+        try {
+            this.db.exec("ALTER TABLE project_contexts ADD COLUMN implementation_plan TEXT");
+        }
+        catch { /* column exists */ }
+        try {
+            this.db.exec("ALTER TABLE project_contexts ADD COLUMN preferred_implementer TEXT");
+        }
+        catch { /* column exists */ }
+        try {
+            this.db.exec("ALTER TABLE project_contexts ADD COLUMN status TEXT NOT NULL DEFAULT 'planning'");
+        }
+        catch { /* column exists */ }
+        // Task review workflow columns
+        try {
+            this.db.exec("ALTER TABLE tasks ADD COLUMN complexity TEXT NOT NULL DEFAULT 'medium'");
+        }
+        catch { /* column exists */ }
+        try {
+            this.db.exec("ALTER TABLE tasks ADD COLUMN review_notes TEXT");
+        }
+        catch { /* column exists */ }
+        try {
+            this.db.exec("ALTER TABLE tasks ADD COLUMN review_feedback TEXT");
+        }
+        catch { /* column exists */ }
+        try {
+            this.db.exec("ALTER TABLE tasks ADD COLUMN review_requested_at TEXT");
+        }
+        catch { /* column exists */ }
+        // Worktree isolation columns
+        try {
+            this.db.exec("ALTER TABLE tasks ADD COLUMN isolation TEXT NOT NULL DEFAULT 'shared'");
+        }
+        catch { /* column exists */ }
+        try {
+            this.db.exec("ALTER TABLE implementers ADD COLUMN isolation TEXT NOT NULL DEFAULT 'shared'");
+        }
+        catch { /* column exists */ }
+        try {
+            this.db.exec("ALTER TABLE implementers ADD COLUMN worktree_path TEXT");
+        }
+        catch { /* column exists */ }
+        try {
+            this.db.exec("ALTER TABLE implementers ADD COLUMN branch_name TEXT");
+        }
+        catch { /* column exists */ }
+    }
+    getDb() {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        return this.db;
+    }
+    parseTask(row) {
+        return {
+            id: row.id,
+            title: row.title,
+            description: row.description ?? undefined,
+            status: row.status,
+            complexity: row.complexity ?? "medium",
+            isolation: row.isolation ?? "shared",
+            owner: row.owner ?? undefined,
+            tags: row.tags ? JSON.parse(row.tags) : undefined,
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+            reviewNotes: row.review_notes ?? undefined,
+            reviewFeedback: row.review_feedback ?? undefined,
+            reviewRequestedAt: row.review_requested_at ?? undefined,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
+    parseLock(row) {
+        return {
+            path: row.path,
+            owner: row.owner ?? undefined,
+            note: row.note ?? undefined,
+            status: row.status,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
+    parseNote(row) {
+        return {
+            id: row.id,
+            text: row.text,
+            author: row.author ?? undefined,
+            createdAt: row.created_at,
+        };
+    }
+    async status() {
+        const db = this.getDb();
+        const tasks = db.prepare("SELECT * FROM tasks ORDER BY created_at ASC").all();
+        const locks = db.prepare("SELECT * FROM locks ORDER BY created_at ASC").all();
+        const notes = db.prepare("SELECT * FROM notes ORDER BY created_at ASC").all();
+        return {
+            tasks: tasks.map((row) => this.parseTask(row)),
+            locks: locks.map((row) => this.parseLock(row)),
+            notes: notes.map((row) => this.parseNote(row)),
+        };
+    }
+    async createTask(input) {
+        const db = this.getDb();
+        const task = {
+            id: crypto.randomUUID(),
+            title: input.title,
+            description: input.description,
+            status: input.status ?? "todo",
+            complexity: input.complexity ?? "medium",
+            isolation: input.isolation ?? "shared",
+            owner: input.owner,
+            tags: input.tags,
+            metadata: input.metadata,
+            createdAt: nowIso(),
+            updatedAt: nowIso(),
+        };
+        db.prepare(`INSERT INTO tasks (id, title, description, status, complexity, isolation, owner, tags, metadata, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(task.id, task.title, task.description ?? null, task.status, task.complexity, task.isolation, task.owner ?? null, task.tags ? JSON.stringify(task.tags) : null, task.metadata ? JSON.stringify(task.metadata) : null, task.createdAt, task.updatedAt);
+        await appendLog(this.logDir, "task_create", { task });
+        return task;
+    }
+    async updateTask(input) {
+        const db = this.getDb();
+        const row = db.prepare("SELECT * FROM tasks WHERE id = ?").get(input.id);
+        if (!row)
+            throw new Error(`Task not found: ${input.id}`);
+        const task = this.parseTask(row);
+        if (input.title !== undefined)
+            task.title = input.title;
+        if (input.description !== undefined)
+            task.description = input.description;
+        if (input.status !== undefined)
+            task.status = input.status;
+        if (input.complexity !== undefined)
+            task.complexity = input.complexity;
+        if (input.isolation !== undefined)
+            task.isolation = input.isolation;
+        if (input.owner !== undefined)
+            task.owner = input.owner;
+        if (input.tags !== undefined)
+            task.tags = input.tags;
+        if (input.metadata !== undefined)
+            task.metadata = input.metadata;
+        if (input.reviewNotes !== undefined)
+            task.reviewNotes = input.reviewNotes;
+        if (input.reviewFeedback !== undefined)
+            task.reviewFeedback = input.reviewFeedback;
+        if (input.reviewRequestedAt !== undefined)
+            task.reviewRequestedAt = input.reviewRequestedAt;
+        task.updatedAt = nowIso();
+        db.prepare(`UPDATE tasks
+       SET title = ?, description = ?, status = ?, complexity = ?, isolation = ?, owner = ?, tags = ?, metadata = ?,
+           review_notes = ?, review_feedback = ?, review_requested_at = ?, updated_at = ?
+       WHERE id = ?`).run(task.title, task.description ?? null, task.status, task.complexity, task.isolation, task.owner ?? null, task.tags ? JSON.stringify(task.tags) : null, task.metadata ? JSON.stringify(task.metadata) : null, task.reviewNotes ?? null, task.reviewFeedback ?? null, task.reviewRequestedAt ?? null, task.updatedAt, task.id);
+        await appendLog(this.logDir, "task_update", { task });
+        return task;
+    }
+    async claimTask(input) {
+        return this.updateTask({ id: input.id, owner: input.owner, status: "in_progress" });
+    }
+    async submitTaskForReview(input) {
+        const db = this.getDb();
+        const row = db.prepare("SELECT * FROM tasks WHERE id = ?").get(input.id);
+        if (!row)
+            throw new Error(`Task not found: ${input.id}`);
+        if (row.owner !== input.owner) {
+            throw new Error(`Task owned by ${row.owner}, not ${input.owner}`);
+        }
+        return this.updateTask({
+            id: input.id,
+            status: "review",
+            reviewNotes: input.reviewNotes,
+            reviewRequestedAt: nowIso(),
+        });
+    }
+    async approveTask(input) {
+        const db = this.getDb();
+        const row = db.prepare("SELECT * FROM tasks WHERE id = ?").get(input.id);
+        if (!row)
+            throw new Error(`Task not found: ${input.id}`);
+        if (row.status !== "review") {
+            throw new Error(`Task is not in review status (current: ${row.status})`);
+        }
+        return this.updateTask({
+            id: input.id,
+            status: "done",
+            reviewFeedback: input.feedback ?? "Approved",
+        });
+    }
+    async requestTaskChanges(input) {
+        const db = this.getDb();
+        const row = db.prepare("SELECT * FROM tasks WHERE id = ?").get(input.id);
+        if (!row)
+            throw new Error(`Task not found: ${input.id}`);
+        if (row.status !== "review") {
+            throw new Error(`Task is not in review status (current: ${row.status})`);
+        }
+        return this.updateTask({
+            id: input.id,
+            status: "in_progress", // Send back to in_progress for rework
+            reviewFeedback: input.feedback,
+        });
+    }
+    async listTasks(filters) {
+        const db = this.getDb();
+        const where = [];
+        const params = [];
+        if (filters?.status) {
+            where.push("status = ?");
+            params.push(filters.status);
+        }
+        if (filters?.owner) {
+            where.push("owner = ?");
+            params.push(filters.owner);
+        }
+        const sql = `SELECT * FROM tasks${where.length ? ` WHERE ${where.join(" AND ")}` : ""} ORDER BY created_at ASC`;
+        let tasks = db.prepare(sql).all(...params).map((row) => this.parseTask(row));
+        if (filters?.tag) {
+            tasks = tasks.filter((task) => task.tags?.includes(filters.tag ?? ""));
+        }
+        if (filters?.limit && filters.limit > 0)
+            tasks = tasks.slice(0, filters.limit);
+        return tasks;
+    }
+    async acquireLock(input) {
+        const db = this.getDb();
+        const lock = {
+            path: input.path,
+            owner: input.owner,
+            note: input.note,
+            status: "active",
+            createdAt: nowIso(),
+            updatedAt: nowIso(),
+        };
+        const transaction = db.transaction(() => {
+            const existing = db
+                .prepare("SELECT * FROM locks WHERE path = ? AND status = 'active'")
+                .get(input.path);
+            if (existing)
+                throw new Error(`Lock already active for ${input.path}`);
+            db.prepare(`INSERT INTO locks (path, owner, note, status, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?)`).run(lock.path, lock.owner ?? null, lock.note ?? null, lock.status, lock.createdAt, lock.updatedAt);
+        });
+        transaction();
+        await appendLog(this.logDir, "lock_acquire", { lock });
+        return lock;
+    }
+    async releaseLock(input) {
+        const db = this.getDb();
+        const row = db
+            .prepare("SELECT * FROM locks WHERE path = ? AND status = 'active'")
+            .get(input.path);
+        if (!row)
+            throw new Error(`Active lock not found for ${input.path}`);
+        const lock = this.parseLock(row);
+        if (input.owner && lock.owner && input.owner !== lock.owner) {
+            throw new Error(`Lock owned by ${lock.owner}, not ${input.owner}`);
+        }
+        lock.status = "resolved";
+        lock.updatedAt = nowIso();
+        db.prepare("UPDATE locks SET status = ?, updated_at = ? WHERE path = ?").run(lock.status, lock.updatedAt, lock.path);
+        await appendLog(this.logDir, "lock_release", { lock });
+        return lock;
+    }
+    async listLocks(filters) {
+        const db = this.getDb();
+        const where = [];
+        const params = [];
+        if (filters?.status) {
+            where.push("status = ?");
+            params.push(filters.status);
+        }
+        if (filters?.owner) {
+            where.push("owner = ?");
+            params.push(filters.owner);
+        }
+        const sql = `SELECT * FROM locks${where.length ? ` WHERE ${where.join(" AND ")}` : ""} ORDER BY created_at ASC`;
+        const locks = db.prepare(sql).all(...params);
+        return locks.map((row) => this.parseLock(row));
+    }
+    async appendNote(input) {
+        const db = this.getDb();
+        const note = {
+            id: crypto.randomUUID(),
+            text: input.text,
+            author: input.author,
+            createdAt: nowIso(),
+        };
+        db.prepare(`INSERT INTO notes (id, text, author, created_at)
+       VALUES (?, ?, ?, ?)`).run(note.id, note.text, note.author ?? null, note.createdAt);
+        await appendLog(this.logDir, "note_append", { note });
+        return note;
+    }
+    async listNotes(limit) {
+        const db = this.getDb();
+        const sql = "SELECT * FROM notes ORDER BY created_at ASC";
+        let notes = db.prepare(sql).all().map((row) => this.parseNote(row));
+        if (limit && limit > 0)
+            notes = notes.slice(Math.max(notes.length - limit, 0));
+        return notes;
+    }
+    async appendLogEntry(event, payload) {
+        await appendLog(this.logDir, event, payload ?? {});
+    }
+    parseProjectContext(row) {
+        return {
+            projectRoot: row.project_root,
+            description: row.description,
+            endState: row.end_state,
+            techStack: row.tech_stack ? JSON.parse(row.tech_stack) : undefined,
+            constraints: row.constraints ? JSON.parse(row.constraints) : undefined,
+            acceptanceCriteria: row.acceptance_criteria ? JSON.parse(row.acceptance_criteria) : undefined,
+            tests: row.tests ? JSON.parse(row.tests) : undefined,
+            implementationPlan: row.implementation_plan ? JSON.parse(row.implementation_plan) : undefined,
+            preferredImplementer: row.preferred_implementer,
+            status: row.status ?? "planning",
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
+    parseImplementer(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            type: row.type,
+            projectRoot: row.project_root,
+            status: row.status,
+            pid: row.pid ?? undefined,
+            isolation: row.isolation ?? "shared",
+            worktreePath: row.worktree_path ?? undefined,
+            branchName: row.branch_name ?? undefined,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
+    async setProjectContext(input) {
+        const db = this.getDb();
+        const existing = db
+            .prepare("SELECT * FROM project_contexts WHERE project_root = ?")
+            .get(input.projectRoot);
+        const context = {
+            projectRoot: input.projectRoot,
+            description: input.description,
+            endState: input.endState,
+            techStack: input.techStack,
+            constraints: input.constraints,
+            acceptanceCriteria: input.acceptanceCriteria,
+            tests: input.tests,
+            implementationPlan: input.implementationPlan,
+            preferredImplementer: input.preferredImplementer ?? existing?.preferred_implementer,
+            status: input.status ?? existing?.status ?? "planning",
+            createdAt: existing?.created_at ?? nowIso(),
+            updatedAt: nowIso(),
+        };
+        if (existing) {
+            db.prepare(`UPDATE project_contexts
+         SET description = ?, end_state = ?, tech_stack = ?, constraints = ?,
+             acceptance_criteria = ?, tests = ?, implementation_plan = ?, preferred_implementer = ?, status = ?, updated_at = ?
+         WHERE project_root = ?`).run(context.description, context.endState, context.techStack ? JSON.stringify(context.techStack) : null, context.constraints ? JSON.stringify(context.constraints) : null, context.acceptanceCriteria ? JSON.stringify(context.acceptanceCriteria) : null, context.tests ? JSON.stringify(context.tests) : null, context.implementationPlan ? JSON.stringify(context.implementationPlan) : null, context.preferredImplementer ?? null, context.status, context.updatedAt, context.projectRoot);
+        }
+        else {
+            db.prepare(`INSERT INTO project_contexts (project_root, description, end_state, tech_stack, constraints,
+         acceptance_criteria, tests, implementation_plan, preferred_implementer, status, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(context.projectRoot, context.description, context.endState, context.techStack ? JSON.stringify(context.techStack) : null, context.constraints ? JSON.stringify(context.constraints) : null, context.acceptanceCriteria ? JSON.stringify(context.acceptanceCriteria) : null, context.tests ? JSON.stringify(context.tests) : null, context.implementationPlan ? JSON.stringify(context.implementationPlan) : null, context.preferredImplementer ?? null, context.status, context.createdAt, context.updatedAt);
+        }
+        await appendLog(this.logDir, "project_context_set", { context });
+        return context;
+    }
+    async getProjectContext(projectRoot) {
+        const db = this.getDb();
+        const row = db
+            .prepare("SELECT * FROM project_contexts WHERE project_root = ?")
+            .get(projectRoot);
+        return row ? this.parseProjectContext(row) : null;
+    }
+    async listAllProjectContexts() {
+        const db = this.getDb();
+        const rows = db
+            .prepare("SELECT * FROM project_contexts ORDER BY updated_at DESC")
+            .all();
+        return rows.map((row) => this.parseProjectContext(row));
+    }
+    async updateProjectStatus(projectRoot, status) {
+        const db = this.getDb();
+        const row = db
+            .prepare("SELECT * FROM project_contexts WHERE project_root = ?")
+            .get(projectRoot);
+        if (!row)
+            throw new Error(`Project context not found: ${projectRoot}`);
+        const updatedAt = nowIso();
+        db.prepare("UPDATE project_contexts SET status = ?, updated_at = ? WHERE project_root = ?")
+            .run(status, updatedAt, projectRoot);
+        await appendLog(this.logDir, "project_status_update", { projectRoot, status });
+        const updated = db
+            .prepare("SELECT * FROM project_contexts WHERE project_root = ?")
+            .get(projectRoot);
+        return this.parseProjectContext(updated);
+    }
+    async registerImplementer(input) {
+        const db = this.getDb();
+        const implementer = {
+            id: crypto.randomUUID(),
+            name: input.name,
+            type: input.type,
+            projectRoot: input.projectRoot,
+            status: "active",
+            pid: input.pid,
+            isolation: input.isolation ?? "shared",
+            worktreePath: input.worktreePath,
+            branchName: input.branchName,
+            createdAt: nowIso(),
+            updatedAt: nowIso(),
+        };
+        db.prepare(`INSERT INTO implementers (id, name, type, project_root, status, pid, isolation, worktree_path, branch_name, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(implementer.id, implementer.name, implementer.type, implementer.projectRoot, implementer.status, implementer.pid ?? null, implementer.isolation, implementer.worktreePath ?? null, implementer.branchName ?? null, implementer.createdAt, implementer.updatedAt);
+        await appendLog(this.logDir, "implementer_register", { implementer });
+        return implementer;
+    }
+    async updateImplementer(id, status) {
+        const db = this.getDb();
+        const row = db.prepare("SELECT * FROM implementers WHERE id = ?").get(id);
+        if (!row)
+            throw new Error(`Implementer not found: ${id}`);
+        const updatedAt = nowIso();
+        db.prepare("UPDATE implementers SET status = ?, updated_at = ? WHERE id = ?")
+            .run(status, updatedAt, id);
+        await appendLog(this.logDir, "implementer_update", { id, status });
+        const updated = db.prepare("SELECT * FROM implementers WHERE id = ?").get(id);
+        return this.parseImplementer(updated);
+    }
+    async listImplementers(projectRoot) {
+        const db = this.getDb();
+        let rows;
+        if (projectRoot) {
+            rows = db.prepare("SELECT * FROM implementers WHERE project_root = ? ORDER BY created_at ASC")
+                .all(projectRoot);
+        }
+        else {
+            rows = db.prepare("SELECT * FROM implementers ORDER BY created_at ASC").all();
+        }
+        return rows.map((row) => this.parseImplementer(row));
+    }
+    async resetImplementers(projectRoot) {
+        const db = this.getDb();
+        const updatedAt = nowIso();
+        const result = db.prepare("UPDATE implementers SET status = 'stopped', updated_at = ? WHERE project_root = ? AND status = 'active'").run(updatedAt, projectRoot);
+        await appendLog(this.logDir, "implementers_reset", { projectRoot, count: result.changes });
+        return result.changes;
+    }
+    async resetSession(projectRoot, options) {
+        const db = this.getDb();
+        // Start transaction for atomic reset
+        const resetTransaction = db.transaction(() => {
+            // Count and clear tasks
+            const taskCount = db.prepare("SELECT COUNT(*) as count FROM tasks").get();
+            const tasksCleared = taskCount.count;
+            db.prepare("DELETE FROM tasks").run();
+            // Count and clear active locks (keep resolved for history if needed)
+            const lockCount = db.prepare("SELECT COUNT(*) as count FROM locks WHERE status = 'active'").get();
+            const locksCleared = lockCount.count;
+            db.prepare("UPDATE locks SET status = 'resolved', updated_at = ? WHERE status = 'active'").run(nowIso());
+            // Also delete all locks if we want a clean slate
+            db.prepare("DELETE FROM locks").run();
+            // Count and clear notes
+            const noteCount = db.prepare("SELECT COUNT(*) as count FROM notes").get();
+            const notesCleared = noteCount.count;
+            db.prepare("DELETE FROM notes").run();
+            // Reset implementers
+            const updatedAt = nowIso();
+            const implResult = db.prepare("UPDATE implementers SET status = 'stopped', updated_at = ? WHERE project_root = ? AND status = 'active'").run(updatedAt, projectRoot);
+            const implementersReset = implResult.changes;
+            // Archive open discussions
+            const discussionResult = db.prepare("UPDATE discussions SET status = 'archived', archived_at = ?, updated_at = ? WHERE project_root = ? AND status IN ('open', 'waiting')").run(nowIso(), nowIso(), projectRoot);
+            const discussionsArchived = discussionResult.changes;
+            // Clear project context unless keepProjectContext is true
+            if (!options?.keepProjectContext) {
+                db.prepare("DELETE FROM project_contexts WHERE project_root = ?").run(projectRoot);
+            }
+            else {
+                // Reset status to planning if keeping context
+                db.prepare("UPDATE project_contexts SET status = 'planning', updated_at = ? WHERE project_root = ?")
+                    .run(nowIso(), projectRoot);
+            }
+            return {
+                tasksCleared,
+                locksCleared,
+                notesCleared,
+                implementersReset,
+                discussionsArchived
+            };
+        });
+        const result = resetTransaction();
+        await appendLog(this.logDir, "session_reset", {
+            projectRoot,
+            ...result
+        });
+        return result;
+    }
+    // Discussion methods
+    parseDiscussion(row) {
+        return {
+            id: row.id,
+            topic: row.topic,
+            category: row.category,
+            priority: row.priority,
+            status: row.status,
+            projectRoot: row.project_root,
+            createdBy: row.created_by,
+            waitingOn: row.waiting_on ?? undefined,
+            decision: row.decision ?? undefined,
+            decisionReasoning: row.decision_reasoning ?? undefined,
+            decidedBy: row.decided_by ?? undefined,
+            linkedTaskId: row.linked_task_id ?? undefined,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            resolvedAt: row.resolved_at ?? undefined,
+            archivedAt: row.archived_at ?? undefined,
+        };
+    }
+    parseDiscussionMessage(row) {
+        return {
+            id: row.id,
+            discussionId: row.discussion_id,
+            author: row.author,
+            message: row.message,
+            recommendation: row.recommendation ?? undefined,
+            createdAt: row.created_at,
+        };
+    }
+    async createDiscussion(input) {
+        const db = this.getDb();
+        const now = nowIso();
+        const discussion = {
+            id: crypto.randomUUID(),
+            topic: input.topic,
+            category: input.category,
+            priority: input.priority,
+            status: input.waitingOn ? "waiting" : "open",
+            projectRoot: input.projectRoot,
+            createdBy: input.createdBy,
+            waitingOn: input.waitingOn,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const msg = {
+            id: crypto.randomUUID(),
+            discussionId: discussion.id,
+            author: input.createdBy,
+            message: input.message,
+            createdAt: now,
+        };
+        db.prepare(`INSERT INTO discussions (id, topic, category, priority, status, project_root, created_by, waiting_on, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(discussion.id, discussion.topic, discussion.category, discussion.priority, discussion.status, discussion.projectRoot, discussion.createdBy, discussion.waitingOn ?? null, discussion.createdAt, discussion.updatedAt);
+        db.prepare(`INSERT INTO discussion_messages (id, discussion_id, author, message, recommendation, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`).run(msg.id, msg.discussionId, msg.author, msg.message, null, msg.createdAt);
+        await appendLog(this.logDir, "discussion_create", { discussion, message: msg });
+        return { discussion, message: msg };
+    }
+    async replyToDiscussion(input) {
+        const db = this.getDb();
+        const now = nowIso();
+        const row = db.prepare("SELECT * FROM discussions WHERE id = ?").get(input.discussionId);
+        if (!row)
+            throw new Error(`Discussion not found: ${input.discussionId}`);
+        if (row.status === "resolved" || row.status === "archived") {
+            throw new Error(`Cannot reply to ${row.status} discussion`);
+        }
+        const msg = {
+            id: crypto.randomUUID(),
+            discussionId: input.discussionId,
+            author: input.author,
+            message: input.message,
+            recommendation: input.recommendation,
+            createdAt: now,
+        };
+        db.prepare(`INSERT INTO discussion_messages (id, discussion_id, author, message, recommendation, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`).run(msg.id, msg.discussionId, msg.author, msg.message, msg.recommendation ?? null, msg.createdAt);
+        // Update discussion status and waiting_on
+        const newStatus = input.waitingOn ? "waiting" : "open";
+        db.prepare(`UPDATE discussions SET status = ?, waiting_on = ?, updated_at = ? WHERE id = ?`).run(newStatus, input.waitingOn ?? null, now, input.discussionId);
+        const updated = db.prepare("SELECT * FROM discussions WHERE id = ?").get(input.discussionId);
+        await appendLog(this.logDir, "discussion_reply", { discussion: this.parseDiscussion(updated), message: msg });
+        return { discussion: this.parseDiscussion(updated), message: msg };
+    }
+    async resolveDiscussion(input) {
+        const db = this.getDb();
+        const now = nowIso();
+        const row = db.prepare("SELECT * FROM discussions WHERE id = ?").get(input.discussionId);
+        if (!row)
+            throw new Error(`Discussion not found: ${input.discussionId}`);
+        db.prepare(`UPDATE discussions
+       SET status = 'resolved', decision = ?, decision_reasoning = ?, decided_by = ?,
+           linked_task_id = ?, waiting_on = NULL, resolved_at = ?, updated_at = ?
+       WHERE id = ?`).run(input.decision, input.reasoning, input.decidedBy, input.linkedTaskId ?? null, now, now, input.discussionId);
+        const updated = db.prepare("SELECT * FROM discussions WHERE id = ?").get(input.discussionId);
+        const discussion = this.parseDiscussion(updated);
+        await appendLog(this.logDir, "discussion_resolve", { discussion });
+        return discussion;
+    }
+    async getDiscussion(id) {
+        const db = this.getDb();
+        const row = db.prepare("SELECT * FROM discussions WHERE id = ?").get(id);
+        if (!row)
+            return null;
+        const msgRows = db.prepare("SELECT * FROM discussion_messages WHERE discussion_id = ? ORDER BY created_at ASC")
+            .all(id);
+        return {
+            discussion: this.parseDiscussion(row),
+            messages: msgRows.map((r) => this.parseDiscussionMessage(r)),
+        };
+    }
+    async listDiscussions(filters) {
+        const db = this.getDb();
+        const where = [];
+        const params = [];
+        if (filters?.status) {
+            where.push("status = ?");
+            params.push(filters.status);
+        }
+        if (filters?.category) {
+            where.push("category = ?");
+            params.push(filters.category);
+        }
+        if (filters?.projectRoot) {
+            where.push("project_root = ?");
+            params.push(filters.projectRoot);
+        }
+        if (filters?.waitingOn) {
+            where.push("waiting_on = ?");
+            params.push(filters.waitingOn);
+        }
+        let sql = `SELECT * FROM discussions${where.length ? ` WHERE ${where.join(" AND ")}` : ""} ORDER BY
+      CASE priority WHEN 'blocking' THEN 1 WHEN 'high' THEN 2 WHEN 'medium' THEN 3 ELSE 4 END,
+      created_at DESC`;
+        if (filters?.limit && filters.limit > 0) {
+            sql += ` LIMIT ${filters.limit}`;
+        }
+        const rows = db.prepare(sql).all(...params);
+        return rows.map((row) => this.parseDiscussion(row));
+    }
+    async archiveDiscussion(id) {
+        const db = this.getDb();
+        const now = nowIso();
+        const row = db.prepare("SELECT * FROM discussions WHERE id = ?").get(id);
+        if (!row)
+            throw new Error(`Discussion not found: ${id}`);
+        db.prepare(`UPDATE discussions SET status = 'archived', archived_at = ?, updated_at = ? WHERE id = ?`).run(now, now, id);
+        const updated = db.prepare("SELECT * FROM discussions WHERE id = ?").get(id);
+        const discussion = this.parseDiscussion(updated);
+        await appendLog(this.logDir, "discussion_archive", { discussion });
+        return discussion;
+    }
+    async archiveOldDiscussions(options) {
+        const db = this.getDb();
+        const days = options.olderThanDays ?? 7;
+        const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
+        const now = nowIso();
+        let sql = `UPDATE discussions SET status = 'archived', archived_at = ?, updated_at = ?
+               WHERE status = 'resolved' AND resolved_at < ?`;
+        const params = [now, now, cutoff];
+        if (options.projectRoot) {
+            sql += " AND project_root = ?";
+            params.push(options.projectRoot);
+        }
+        const result = db.prepare(sql).run(...params);
+        await appendLog(this.logDir, "discussions_bulk_archive", { count: result.changes, olderThanDays: days });
+        return result.changes;
+    }
+    async deleteArchivedDiscussions(options) {
+        const db = this.getDb();
+        const days = options.olderThanDays ?? 30;
+        const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
+        // First get IDs to delete
+        let selectSql = `SELECT id FROM discussions WHERE status = 'archived' AND archived_at < ?`;
+        const selectParams = [cutoff];
+        if (options.projectRoot) {
+            selectSql += " AND project_root = ?";
+            selectParams.push(options.projectRoot);
+        }
+        const ids = db.prepare(selectSql).all(...selectParams);
+        if (ids.length === 0)
+            return 0;
+        const idList = ids.map((r) => r.id);
+        // Delete messages first (foreign key)
+        const placeholders = idList.map(() => "?").join(",");
+        db.prepare(`DELETE FROM discussion_messages WHERE discussion_id IN (${placeholders})`).run(...idList);
+        // Delete discussions
+        const result = db.prepare(`DELETE FROM discussions WHERE id IN (${placeholders})`).run(...idList);
+        await appendLog(this.logDir, "discussions_bulk_delete", { count: result.changes, olderThanDays: days });
+        return result.changes;
+    }
+}
+export function createStore(config) {
+    if (config.storage === "json") {
+        return new JsonStore(config.dataDir, config.logDir);
+    }
+    return new SqliteStore(config.dbPath, config.logDir);
+}