@danalexilewis/taskgraph 0.1.0

package/dist/cli/start.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startCommand = startCommand;
+const uuid_1 = require("uuid");
+const commit_1 = require("../db/commit");
+const utils_1 = require("./utils"); // Import Config
+const invariants_1 = require("../domain/invariants");
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+const query_1 = require("../db/query");
+const connection_1 = require("../db/connection");
+const escape_1 = require("../db/escape");
+function startCommand(program) {
+    program
+        .command("start")
+        .description("Start a task")
+        .argument("<taskId>", "ID of the task to start")
+        .option("--agent <name>", "Agent identifier for multi-agent visibility")
+        .option("--force", "Override claim when task is already being worked")
+        .action(async (taskId, options, cmd) => {
+        const agentName = options.agent ?? "default";
+        const force = options.force ?? false;
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            const currentTimestamp = (0, query_1.now)();
+            const q = (0, query_1.query)(config.doltRepoPath);
+            return q
+                .select("task", {
+                columns: ["status"],
+                where: { task_id: taskId },
+            })
+                .andThen((currentStatusResult) => {
+                if (currentStatusResult.length === 0) {
+                    return (0, neverthrow_1.err)((0, errors_1.buildError)(errors_1.ErrorCode.TASK_NOT_FOUND, `Task with ID ${taskId} not found.`));
+                }
+                const currentStatus = currentStatusResult[0].status;
+                if (currentStatus === "doing" && !force) {
+                    const sql = `SELECT body FROM \`event\` WHERE task_id = '${(0, escape_1.sqlEscape)(taskId)}' AND kind = 'started' ORDER BY created_at DESC LIMIT 1`;
+                    return (0, connection_1.doltSql)(sql, config.doltRepoPath).andThen((rows) => {
+                        const row = rows[0];
+                        const raw = row?.body;
+                        const parsed = raw != null
+                            ? typeof raw === "string"
+                                ? JSON.parse(raw)
+                                : raw
+                            : null;
+                        const claimant = parsed?.agent ?? "unknown";
+                        return (0, neverthrow_1.err)((0, errors_1.buildError)(errors_1.ErrorCode.TASK_ALREADY_CLAIMED, `Task is being worked by ${claimant}. Use --force to override.`));
+                    });
+                }
+                if (currentStatus === "todo") {
+                    return (0, invariants_1.checkRunnable)(taskId, config.doltRepoPath);
+                }
+                if (currentStatus === "doing" && force) {
+                    return (0, neverthrow_1.okAsync)(undefined); // Bypass claim guard
+                }
+                const tr = (0, invariants_1.checkValidTransition)(currentStatus, "doing");
+                return tr.isOk() ? (0, neverthrow_1.okAsync)(undefined) : (0, neverthrow_1.errAsync)(tr.error);
+            })
+                .andThen(() => q.update("task", { status: "doing", updated_at: currentTimestamp }, { task_id: taskId }))
+                .andThen(() => q.insert("event", {
+                event_id: (0, uuid_1.v4)(),
+                task_id: taskId,
+                kind: "started",
+                body: (0, query_1.jsonObj)({
+                    agent: agentName,
+                    timestamp: currentTimestamp,
+                }),
+                created_at: currentTimestamp,
+            }))
+                .andThen(() => (0, commit_1.doltCommit)(`task: start ${taskId}`, config.doltRepoPath, cmd.parent?.opts().noCommit))
+                .map(() => ({ task_id: taskId, status: "doing" }));
+        });
+        result.match((data) => {
+            const resultData = data;
+            if (!cmd.parent?.opts().json) {
+                console.log(`Task ${resultData.task_id} started.`);
+            }
+            else {
+                console.log(JSON.stringify(resultData, null, 2));
+            }
+        }, (error) => {
+            console.error(`Error starting task: ${error.message}`);
+            if (cmd.parent?.opts().json) {
+                console.log(JSON.stringify({
+                    status: "error",
+                    code: error.code,
+                    message: error.message,
+                    cause: error.cause,
+                }));
+            }
+            process.exit(1);
+        });
+    });
+}

package/dist/cli/status.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusCommand = statusCommand;
+const utils_1 = require("./utils");
+const query_1 = require("../db/query");
+const escape_1 = require("../db/escape");
+function backtickWrap(name) {
+    return `\`${name}\``;
+}
+function statusCommand(program) {
+    program
+        .command("status")
+        .description("Quick overview: plans count, tasks by status, next runnable tasks")
+        .option("--plan <planId>", "Filter by plan ID or title")
+        .option("--domain <domain>", "Filter by task domain")
+        .option("--skill <skill>", "Filter by task skill")
+        .option("--change-type <type>", "Filter by change type: create, modify, refactor, fix, investigate, test, document")
+        .action(async (options, cmd) => {
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            const q = (0, query_1.query)(config.doltRepoPath);
+            const isUUID = options.plan &&
+                /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(options.plan);
+            let planWhere = "";
+            if (options.plan) {
+                if (isUUID) {
+                    planWhere = `WHERE ${backtickWrap("plan_id")} = '${(0, escape_1.sqlEscape)(options.plan)}'`;
+                }
+                else {
+                    planWhere = `WHERE ${backtickWrap("title")} = '${(0, escape_1.sqlEscape)(options.plan)}'`;
+                }
+            }
+            const dimFilter = (options.domain
+                ? ` AND EXISTS (SELECT 1 FROM \`task_domain\` td WHERE td.task_id = t.task_id AND td.domain = '${(0, escape_1.sqlEscape)(options.domain)}')`
+                : "") +
+                (options.skill
+                    ? ` AND EXISTS (SELECT 1 FROM \`task_skill\` ts WHERE ts.task_id = t.task_id AND ts.skill = '${(0, escape_1.sqlEscape)(options.skill)}')`
+                    : "") +
+                (options.changeType
+                    ? ` AND t.\`change_type\` = '${(0, escape_1.sqlEscape)(options.changeType)}'`
+                    : "");
+            const planFilter = options.plan
+                ? isUUID
+                    ? `WHERE p.plan_id = '${(0, escape_1.sqlEscape)(options.plan)}'`
+                    : `WHERE p.title = '${(0, escape_1.sqlEscape)(options.plan)}'`
+                : "";
+            const plansCountSql = dimFilter
+                ? `SELECT COUNT(DISTINCT p.plan_id) AS count FROM \`plan\` p JOIN \`task\` t ON t.plan_id = p.plan_id ${planFilter || "WHERE 1=1"} ${dimFilter}`
+                : `SELECT COUNT(*) AS count FROM \`plan\` ${planWhere}`;
+            const statusCountsSql = `SELECT t.status, COUNT(*) AS count FROM \`task\` t JOIN \`plan\` p ON t.plan_id = p.plan_id ${planFilter || "WHERE 1=1"} ${dimFilter} GROUP BY t.status`;
+            const nextSql = `
+          SELECT t.task_id, t.title, p.title as plan_title
+          FROM \`task\` t
+          JOIN \`plan\` p ON t.plan_id = p.plan_id
+          WHERE t.status = 'todo'
+          AND (SELECT COUNT(*) FROM \`edge\` e
+               JOIN \`task\` bt ON e.from_task_id = bt.task_id
+               WHERE e.to_task_id = t.task_id AND e.type = 'blocks'
+               AND bt.status NOT IN ('done','canceled')) = 0
+          ${options.plan ? (isUUID ? `AND p.plan_id = '${(0, escape_1.sqlEscape)(options.plan)}'` : `AND p.title = '${(0, escape_1.sqlEscape)(options.plan)}'`) : ""}
+          ${dimFilter}
+          ORDER BY p.priority DESC, t.created_at ASC
+          LIMIT 2
+        `;
+            const activeWorkSql = `
+          SELECT t.task_id, t.title, p.title as plan_title, e.body, e.created_at
+          FROM \`task\` t
+          JOIN \`plan\` p ON t.plan_id = p.plan_id
+          JOIN \`event\` e ON e.task_id = t.task_id AND e.kind = 'started'
+          WHERE t.status = 'doing'
+          AND e.created_at = (
+            SELECT MAX(e2.created_at) FROM \`event\` e2
+            WHERE e2.task_id = t.task_id AND e2.kind = 'started'
+          )
+          ${options.plan ? (isUUID ? `AND p.plan_id = '${(0, escape_1.sqlEscape)(options.plan)}'` : `AND p.title = '${(0, escape_1.sqlEscape)(options.plan)}'`) : ""}
+          ${dimFilter}
+          ORDER BY e.created_at DESC
+        `;
+            return q.raw(plansCountSql).andThen((plansRes) => {
+                const plansCount = plansRes[0]?.count ?? 0;
+                return q
+                    .raw(statusCountsSql)
+                    .andThen((statusRows) => {
+                    const statusCounts = {};
+                    statusRows.forEach((r) => {
+                        statusCounts[r.status] = r.count;
+                    });
+                    return q
+                        .raw(nextSql)
+                        .andThen((nextTasks) => q
+                        .raw(activeWorkSql)
+                        .map((activeWork) => ({
+                        plansCount,
+                        statusCounts,
+                        nextTasks,
+                        activeWork,
+                    })));
+                });
+            });
+        });
+        result.match((data) => {
+            const d = data;
+            if (!(0, utils_1.rootOpts)(cmd).json) {
+                console.log(`Plans: ${d.plansCount}`);
+                const statusOrder = [
+                    "todo",
+                    "doing",
+                    "blocked",
+                    "done",
+                    "canceled",
+                ];
+                statusOrder.forEach((s) => {
+                    const count = d.statusCounts[s] ?? 0;
+                    if (count > 0)
+                        console.log(`  ${s}: ${count}`);
+                });
+                if (d.activeWork.length > 0) {
+                    console.log("Active work:");
+                    d.activeWork.forEach((w) => {
+                        const body = typeof w.body === "string"
+                            ? JSON.parse(w.body)
+                            : w.body;
+                        const agent = body?.agent ?? "unknown";
+                        console.log(`  ${w.task_id}  ${w.title} (${w.plan_title}) [${agent}] ${w.created_at}`);
+                    });
+                }
+                if (d.nextTasks.length > 0) {
+                    console.log("Next runnable:");
+                    d.nextTasks.forEach((t) => {
+                        console.log(`  ${t.task_id}  ${t.title} (${t.plan_title})`);
+                    });
+                }
+            }
+            else {
+                console.log(JSON.stringify(d, null, 2));
+            }
+        }, (error) => {
+            console.error(`Error fetching status: ${error.message}`);
+            if ((0, utils_1.rootOpts)(cmd).json) {
+                console.log(JSON.stringify({
+                    status: "error",
+                    code: error.code,
+                    message: error.message,
+                    cause: error.cause,
+                }));
+            }
+            process.exit(1);
+        });
+    });
+}

package/dist/cli/task.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskCommand = taskCommand;
+const commander_1 = require("commander");
+const uuid_1 = require("uuid");
+const commit_1 = require("../db/commit");
+const utils_1 = require("./utils");
+const neverthrow_1 = require("neverthrow"); // Import errAsync
+const errors_1 = require("../domain/errors");
+const query_1 = require("../db/query");
+function taskCommand(program) {
+    program
+        .command("task")
+        .description("Manage tasks")
+        .addCommand(taskNewCommand());
+}
+function taskNewCommand() {
+    return new commander_1.Command("new")
+        .description("Create a new task")
+        .argument("<title>", "Title of the task")
+        .requiredOption("--plan <planId>", "ID of the parent plan") // Changed to requiredOption
+        .option("--feature <featureKey>", "Feature key for portfolio analysis")
+        .option("--area <area>", "Area of the task (e.g., frontend, backend)")
+        .option("--acceptance <json>", "JSON array of acceptance checks")
+        .action(async (title, options, cmd) => {
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            // Removed async, added type
+            const task_id = (0, uuid_1.v4)();
+            const currentTimestamp = (0, query_1.now)();
+            const q = (0, query_1.query)(config.doltRepoPath);
+            let acceptanceJson = null;
+            if (options.acceptance) {
+                try {
+                    const parsedAcceptance = JSON.parse(options.acceptance);
+                    acceptanceJson = (0, query_1.jsonObj)({ val: options.acceptance });
+                }
+                catch (e) {
+                    return (0, neverthrow_1.errAsync)((0, errors_1.buildError)(errors_1.ErrorCode.VALIDATION_FAILED, `Invalid JSON for acceptance criteria: ${options.acceptance}`, e));
+                }
+            }
+            return q
+                .insert("task", {
+                task_id,
+                plan_id: options.plan,
+                feature_key: options.feature ?? null,
+                title,
+                area: options.area ?? null,
+                acceptance: acceptanceJson,
+                created_at: currentTimestamp,
+                updated_at: currentTimestamp,
+            })
+                .andThen(() => {
+                return q.insert("event", {
+                    event_id: (0, uuid_1.v4)(),
+                    task_id,
+                    kind: "created",
+                    body: (0, query_1.jsonObj)({ title }),
+                    created_at: currentTimestamp,
+                });
+            })
+                .andThen(() => (0, commit_1.doltCommit)(`task: create ${task_id} - ${title}`, config.doltRepoPath, (0, utils_1.rootOpts)(cmd).noCommit))
+                .map(() => ({
+                task_id,
+                plan_id: options.plan,
+                title,
+                feature_key: options.feature,
+                area: options.area,
+            }));
+        });
+        result.match((data) => {
+            // Type unknown
+            const resultData = data; // Cast to Task
+            if (!(0, utils_1.rootOpts)(cmd).json) {
+                console.log(`Task created with ID: ${resultData.task_id} for Plan ID: ${resultData.plan_id}`);
+            }
+            else {
+                console.log(JSON.stringify(resultData, null, 2));
+            }
+        }, (error) => {
+            console.error(`Error creating task: ${error.message}`);
+            if ((0, utils_1.rootOpts)(cmd).json) {
+                console.log(JSON.stringify({
+                    status: "error",
+                    code: error.code,
+                    message: error.message,
+                    cause: error.cause,
+                }));
+            }
+            process.exit(1);
+        });
+    });
+}

package/dist/cli/utils.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rootOpts = rootOpts;
+exports.readConfig = readConfig;
+exports.writeConfig = writeConfig;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+const TASKGRAPH_DIR = ".taskgraph";
+/** Walk to root command to access global options like --json */
+function rootOpts(cmd) {
+    let c = cmd;
+    while (c?.parent)
+        c = c.parent;
+    return (c?.opts?.() ?? {});
+}
+const CONFIG_FILE = path.join(TASKGRAPH_DIR, "config.json");
+function readConfig(basePath) {
+    const configPath = path.join(basePath ?? process.cwd(), CONFIG_FILE);
+    if (!(0, fs_1.existsSync)(configPath)) {
+        return (0, neverthrow_1.err)((0, errors_1.buildError)(errors_1.ErrorCode.CONFIG_NOT_FOUND, `Config file not found at ${configPath}. Please run 'tg init' first.`));
+    }
+    try {
+        const configContents = (0, fs_1.readFileSync)(configPath, "utf-8");
+        return (0, neverthrow_1.ok)(JSON.parse(configContents));
+    }
+    catch (e) {
+        return (0, neverthrow_1.err)((0, errors_1.buildError)(errors_1.ErrorCode.CONFIG_PARSE_FAILED, `Failed to parse config file at ${configPath}`, e));
+    }
+}
+function writeConfig(config, basePath) {
+    const configPath = path.join(basePath ?? process.cwd(), CONFIG_FILE);
+    try {
+        (0, fs_1.writeFileSync)(configPath, JSON.stringify(config, null, 2));
+        return (0, neverthrow_1.ok)(undefined);
+    }
+    catch (e) {
+        return (0, neverthrow_1.err)((0, errors_1.buildError)(errors_1.ErrorCode.CONFIG_PARSE_FAILED, `Failed to write config file to ${configPath}`, e));
+    }
+}

package/dist/db/commit.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doltCommit = doltCommit;
+const execa_1 = require("execa");
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+function doltCommit(msg, repoPath, noCommit = false) {
+    if (noCommit) {
+        return neverthrow_1.ResultAsync.fromPromise(Promise.resolve(), () => (0, errors_1.buildError)(errors_1.ErrorCode.DB_COMMIT_FAILED, "Dry run commit failed"));
+    }
+    return neverthrow_1.ResultAsync.fromPromise((0, execa_1.execa)("dolt", ["add", "-A"], { cwd: repoPath }), (e) => (0, errors_1.buildError)(errors_1.ErrorCode.DB_COMMIT_FAILED, `Dolt add failed before commit: ${msg}`, e))
+        .andThen(() => {
+        return neverthrow_1.ResultAsync.fromPromise((0, execa_1.execa)("dolt", ["commit", "-m", msg, "--allow-empty"], {
+            cwd: repoPath,
+        }), (e) => (0, errors_1.buildError)(errors_1.ErrorCode.DB_COMMIT_FAILED, `Dolt commit failed: ${msg}`, e));
+    })
+        .map(() => undefined);
+}

package/dist/db/connection.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doltSql = doltSql;
+const execa_1 = require("execa");
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+function doltSql(query, repoPath) {
+    return neverthrow_1.ResultAsync.fromPromise((0, execa_1.execa)(process.env.DOLT_PATH || "dolt", ["sql", "-q", query, "-r", "json"], {
+        cwd: repoPath,
+    }), (e) => (0, errors_1.buildError)(errors_1.ErrorCode.DB_QUERY_FAILED, `Dolt SQL query failed: ${query}`, e)).andThen((result) => {
+        const out = (result.stdout || "").trim();
+        if (!out)
+            return (0, neverthrow_1.ok)([]); // DML (INSERT/UPDATE/DELETE) returns no JSON
+        try {
+            const parsed = JSON.parse(out);
+            return (0, neverthrow_1.ok)(parsed?.rows ?? []);
+        }
+        catch (e) {
+            return (0, neverthrow_1.err)((0, errors_1.buildError)(errors_1.ErrorCode.DB_PARSE_FAILED, `Failed to parse Dolt SQL output: ${result.stdout}`, e));
+        }
+    });
+}

package/dist/db/escape.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqlEscape = sqlEscape;
+function sqlEscape(value) {
+    return value.replace(/\\/g, "\\\\").replace(/'/g, "''").replace(/\0/g, "");
+}

package/dist/db/migrate.js

@@ -0,0 +1,159 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPlanRichFieldsMigration = applyPlanRichFieldsMigration;
+exports.applyTaskDimensionsMigration = applyTaskDimensionsMigration;
+exports.applyTaskSuggestedChangesMigration = applyTaskSuggestedChangesMigration;
+exports.applyTaskDomainSkillJunctionMigration = applyTaskDomainSkillJunctionMigration;
+exports.ensureMigrations = ensureMigrations;
+exports.applyMigrations = applyMigrations;
+const connection_1 = require("./connection");
+const commit_1 = require("./commit");
+const fs = __importStar(require("fs"));
+const execa_1 = require("execa");
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+const SCHEMA = [
+    "CREATE TABLE IF NOT EXISTS `plan` (plan_id CHAR(36) PRIMARY KEY, title VARCHAR(255) NOT NULL, intent TEXT NOT NULL, status ENUM(\'draft\',\'active\',\'paused\',\'done\',\'abandoned\') DEFAULT \'draft\', priority INT DEFAULT 0, source_path VARCHAR(512) NULL, source_commit VARCHAR(64) NULL, created_at DATETIME NOT NULL, updated_at DATETIME NOT NULL);",
+    "CREATE TABLE IF NOT EXISTS `task` (task_id CHAR(36) PRIMARY KEY, plan_id CHAR(36) NOT NULL, feature_key VARCHAR(64) NULL, title VARCHAR(255) NOT NULL, intent TEXT NULL, scope_in TEXT NULL, scope_out TEXT NULL, acceptance JSON NULL, status ENUM(\'todo\',\'doing\',\'blocked\',\'done\',\'canceled\') DEFAULT \'todo\', owner ENUM('human','agent') DEFAULT 'agent', area VARCHAR(64) NULL, risk ENUM('low','medium','high') DEFAULT 'low', estimate_mins INT NULL, created_at DATETIME NOT NULL, updated_at DATETIME NOT NULL, external_key VARCHAR(128) NULL UNIQUE, FOREIGN KEY (plan_id) REFERENCES `plan`(plan_id));",
+    "CREATE TABLE IF NOT EXISTS `edge` (from_task_id CHAR(36) NOT NULL, to_task_id CHAR(36) NOT NULL, type ENUM(\'blocks\',\'relates\') DEFAULT \'blocks\', reason TEXT NULL, PRIMARY KEY (from_task_id, to_task_id, type), FOREIGN KEY (from_task_id) REFERENCES `task`(task_id), FOREIGN KEY (to_task_id) REFERENCES `task`(task_id));",
+    "CREATE TABLE IF NOT EXISTS `event` (event_id CHAR(36) PRIMARY KEY, task_id CHAR(36) NOT NULL, kind ENUM(\'created\',\'started\',\'progress\',\'blocked\',\'unblocked\',\'done\',\'split\',\'decision_needed\',\'note\') NOT NULL, body JSON NOT NULL, actor ENUM(\'human\',\'agent\') DEFAULT \'agent\', created_at DATETIME NOT NULL, FOREIGN KEY (task_id) REFERENCES `task`(task_id));",
+    "CREATE TABLE IF NOT EXISTS `decision` (decision_id CHAR(36) PRIMARY KEY, plan_id CHAR(36) NOT NULL, task_id CHAR(36) NULL, summary VARCHAR(255) NOT NULL, context TEXT NOT NULL, options JSON NULL, decision TEXT NOT NULL, consequences TEXT NULL, source_ref VARCHAR(512) NULL, created_at DATETIME NOT NULL, FOREIGN KEY (plan_id) REFERENCES `plan`(plan_id), FOREIGN KEY (task_id) REFERENCES `task`(task_id));",
+];
+/** Returns true if the task table has the given column. */
+function taskColumnExists(repoPath, columnName) {
+    const q = `SELECT 1 FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = 'task' AND COLUMN_NAME = '${columnName}' LIMIT 1`;
+    return (0, connection_1.doltSql)(q, repoPath).map((rows) => rows.length > 0);
+}
+/** Returns true if the plan table has the given column. */
+function planColumnExists(repoPath, columnName) {
+    const q = `SELECT 1 FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = 'plan' AND COLUMN_NAME = '${columnName}' LIMIT 1`;
+    return (0, connection_1.doltSql)(q, repoPath).map((rows) => rows.length > 0);
+}
+/** Add file_tree, risks, tests columns to plan table if missing (idempotent). */
+function applyPlanRichFieldsMigration(repoPath, noCommit = false) {
+    return planColumnExists(repoPath, "file_tree").andThen((hasFileTree) => {
+        if (hasFileTree)
+            return neverthrow_1.ResultAsync.fromSafePromise(Promise.resolve());
+        const alter = "ALTER TABLE `plan` ADD COLUMN `file_tree` TEXT NULL, ADD COLUMN `risks` JSON NULL, ADD COLUMN `tests` JSON NULL";
+        return (0, connection_1.doltSql)(alter, repoPath)
+            .map(() => undefined)
+            .andThen(() => (0, commit_1.doltCommit)("db: add plan rich fields (file_tree, risks, tests)", repoPath, noCommit))
+            .map(() => undefined);
+    });
+}
+/** Add domain, skill, change_type columns to task table if missing (idempotent). */
+function applyTaskDimensionsMigration(repoPath, noCommit = false) {
+    return tableExists(repoPath, "task_domain").andThen((hasJunction) => {
+        if (hasJunction)
+            return neverthrow_1.ResultAsync.fromSafePromise(Promise.resolve()); // Already migrated to junction tables
+        return taskColumnExists(repoPath, "domain").andThen((hasDomain) => {
+            if (hasDomain)
+                return neverthrow_1.ResultAsync.fromSafePromise(Promise.resolve());
+            const alter = "ALTER TABLE `task` ADD COLUMN `domain` VARCHAR(64) NULL, ADD COLUMN `skill` VARCHAR(64) NULL, ADD COLUMN `change_type` ENUM('create','modify','refactor','fix','investigate','test','document') NULL";
+            return (0, connection_1.doltSql)(alter, repoPath)
+                .map(() => undefined)
+                .andThen(() => (0, commit_1.doltCommit)("db: add task dimensions (domain, skill, change_type)", repoPath, noCommit))
+                .map(() => undefined);
+        });
+    });
+}
+/** Add suggested_changes column to task table if missing (idempotent). */
+function applyTaskSuggestedChangesMigration(repoPath, noCommit = false) {
+    return taskColumnExists(repoPath, "suggested_changes").andThen((hasCol) => {
+        if (hasCol)
+            return neverthrow_1.ResultAsync.fromSafePromise(Promise.resolve());
+        const alter = "ALTER TABLE `task` ADD COLUMN `suggested_changes` TEXT NULL";
+        return (0, connection_1.doltSql)(alter, repoPath)
+            .map(() => undefined)
+            .andThen(() => (0, commit_1.doltCommit)("db: add task suggested_changes column", repoPath, noCommit))
+            .map(() => undefined);
+    });
+}
+/** Returns true if the table exists. */
+function tableExists(repoPath, tableName) {
+    const q = `SELECT 1 FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = '${tableName}' LIMIT 1`;
+    return (0, connection_1.doltSql)(q, repoPath).map((rows) => rows.length > 0);
+}
+/** Replace task.domain/task.skill with task_domain and task_skill junction tables; migrate data and drop columns. */
+function applyTaskDomainSkillJunctionMigration(repoPath, noCommit = false) {
+    return tableExists(repoPath, "task_domain").andThen((exists) => {
+        if (exists)
+            return neverthrow_1.ResultAsync.fromSafePromise(Promise.resolve());
+        return (0, connection_1.doltSql)(`CREATE TABLE \`task_domain\` (task_id CHAR(36) NOT NULL, domain VARCHAR(64) NOT NULL, PRIMARY KEY (task_id, domain), FOREIGN KEY (task_id) REFERENCES \`task\`(task_id))`, repoPath)
+            .andThen(() => (0, connection_1.doltSql)(`CREATE TABLE \`task_skill\` (task_id CHAR(36) NOT NULL, skill VARCHAR(64) NOT NULL, PRIMARY KEY (task_id, skill), FOREIGN KEY (task_id) REFERENCES \`task\`(task_id))`, repoPath))
+            .andThen(() => taskColumnExists(repoPath, "domain").andThen((hasDomain) => {
+            if (!hasDomain)
+                return neverthrow_1.ResultAsync.fromSafePromise(Promise.resolve());
+            return (0, connection_1.doltSql)("INSERT INTO `task_domain` (task_id, domain) SELECT task_id, domain FROM `task` WHERE domain IS NOT NULL", repoPath).andThen(() => (0, connection_1.doltSql)("INSERT INTO `task_skill` (task_id, skill) SELECT task_id, skill FROM `task` WHERE skill IS NOT NULL", repoPath));
+        }))
+            .andThen(() => taskColumnExists(repoPath, "domain").andThen((hasDomain) => {
+            if (!hasDomain)
+                return neverthrow_1.ResultAsync.fromSafePromise(Promise.resolve());
+            return (0, connection_1.doltSql)("ALTER TABLE `task` DROP COLUMN `domain`, DROP COLUMN `skill`", repoPath);
+        }))
+            .andThen(() => (0, commit_1.doltCommit)("db: task_domain/task_skill junction tables; drop task.domain/task.skill", repoPath, noCommit))
+            .map(() => undefined);
+    });
+}
+/** Chains all idempotent migrations. Safe to run on every command. */
+function ensureMigrations(repoPath, noCommit = false) {
+    return applyPlanRichFieldsMigration(repoPath, noCommit)
+        .andThen(() => applyTaskDimensionsMigration(repoPath, noCommit))
+        .andThen(() => applyTaskSuggestedChangesMigration(repoPath, noCommit))
+        .andThen(() => applyTaskDomainSkillJunctionMigration(repoPath, noCommit))
+        .map(() => undefined);
+}
+function applyMigrations(repoPath, noCommit = false) {
+    return neverthrow_1.ResultAsync.fromPromise((async () => {
+        for (const statement of SCHEMA) {
+            const tempSqlFile = `${repoPath}/temp_migration.sql`;
+            fs.writeFileSync(tempSqlFile, statement);
+            const res = await neverthrow_1.ResultAsync.fromPromise((0, execa_1.execa)(process.env.DOLT_PATH || "dolt", ["sql"], {
+                cwd: repoPath,
+                shell: true,
+                input: fs.readFileSync(tempSqlFile, "utf8"),
+            }), (e) => (0, errors_1.buildError)(errors_1.ErrorCode.DB_QUERY_FAILED, `Dolt SQL query failed for statement: ${statement}`, e));
+            fs.unlinkSync(tempSqlFile);
+            if (res.isErr()) {
+                console.error("Migration failed:", statement, res.error);
+                throw res.error;
+            }
+        }
+        return undefined;
+    })(), (e) => (0, errors_1.buildError)(errors_1.ErrorCode.DB_QUERY_FAILED, "Failed to apply schema migrations", e))
+        .andThen(() => (0, commit_1.doltCommit)("db: apply schema migrations", repoPath, noCommit))
+        .map(() => undefined);
+}