@kaban-board/core 0.3.1 → 0.3.3

package/dist/index.js

@@ -75,15 +75,19 @@ var exports_schema = {};
 __export(exports_schema, {
   undoLog: () => undoLog,
   tasks: () => tasks,
+  taskLinks: () => taskLinks,
+  linkTypes: () => linkTypes,
   columns: () => columns,
-  boards: () => boards
+  boards: () => boards,
+  audits: () => audits
 });
 import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
-var boards, columns, tasks, undoLog;
+var boards, columns, tasks, undoLog, audits, linkTypes, taskLinks;
 var init_schema = __esm(() => {
   boards = sqliteTable("boards", {
     id: text("id").primaryKey(),
     name: text("name").notNull(),
+    maxBoardTaskId: integer("max_board_task_id").notNull().default(0),
     createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
     updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
   });
@@ -97,6 +101,7 @@ var init_schema = __esm(() => {
   });
   tasks = sqliteTable("tasks", {
     id: text("id").primaryKey(),
+    boardTaskId: integer("board_task_id"),
     title: text("title").notNull(),
     description: text("description"),
     columnId: text("column_id").notNull().references(() => columns.id),
@@ -113,8 +118,10 @@ var init_schema = __esm(() => {
     updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
     startedAt: integer("started_at", { mode: "timestamp" }),
     completedAt: integer("completed_at", { mode: "timestamp" }),
+    dueDate: integer("due_date", { mode: "timestamp" }),
     archived: integer("archived", { mode: "boolean" }).notNull().default(false),
-    archivedAt: integer("archived_at", { mode: "timestamp" })
+    archivedAt: integer("archived_at", { mode: "timestamp" }),
+    updatedBy: text("updated_by")
   });
   undoLog = sqliteTable("undo_log", {
     id: integer("id").primaryKey({ autoIncrement: true }),
@@ -122,6 +129,25 @@ var init_schema = __esm(() => {
     data: text("data", { mode: "json" }).notNull(),
     createdAt: integer("created_at", { mode: "timestamp" }).notNull()
   });
+  audits = sqliteTable("audits", {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    timestamp: integer("timestamp", { mode: "timestamp" }).notNull(),
+    eventType: text("event_type", { enum: ["CREATE", "UPDATE", "DELETE"] }).notNull(),
+    objectType: text("object_type", { enum: ["task", "column", "board"] }).notNull(),
+    objectId: text("object_id").notNull(),
+    fieldName: text("field_name"),
+    oldValue: text("old_value"),
+    newValue: text("new_value"),
+    actor: text("actor")
+  });
+  linkTypes = ["blocks", "blocked_by", "related"];
+  taskLinks = sqliteTable("task_links", {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    fromTaskId: text("from_task_id").notNull().references(() => tasks.id, { onDelete: "cascade" }),
+    toTaskId: text("to_task_id").notNull().references(() => tasks.id, { onDelete: "cascade" }),
+    linkType: text("link_type", { enum: linkTypes }).notNull(),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull()
+  });
 });
 
 // drizzle/meta/_journal.json
@@ -151,6 +177,41 @@ var init__journal = __esm(() => {
         when: 1769351200000,
         tag: "0002_add_fts5",
         breakpoints: true
+      },
+      {
+        idx: 3,
+        version: "6",
+        when: 1769695200000,
+        tag: "0003_fix_fts_compatibility",
+        breakpoints: true
+      },
+      {
+        idx: 4,
+        version: "6",
+        when: 1769700000000,
+        tag: "0004_board_scoped_ids",
+        breakpoints: true
+      },
+      {
+        idx: 5,
+        version: "6",
+        when: 1769800000000,
+        tag: "0005_audit_log",
+        breakpoints: true
+      },
+      {
+        idx: 6,
+        version: "6",
+        when: 1769900000000,
+        tag: "0006_due_date",
+        breakpoints: true
+      },
+      {
+        idx: 7,
+        version: "6",
+        when: 1770000000000,
+        tag: "0007_task_links",
+        breakpoints: true
       }
     ]
   };
@@ -211,6 +272,216 @@ WHERE NOT EXISTS (SELECT 1 FROM tasks_fts LIMIT 1);
 `;
 var init_0002_add_fts5 = () => {};
 
+// drizzle/0003_fix_fts_compatibility.sql
+var _0003_fix_fts_compatibility_default = `-- Fix FTS5 for cross-driver compatibility (bun:sqlite + libsql)
+-- Replaces external-content FTS with simple standalone FTS
+-- Uses DELETE/UPDATE triggers instead of FTS5 'delete' command
+DROP TABLE IF EXISTS tasks_fts;
+
+--> statement-breakpoint
+DROP TRIGGER IF EXISTS tasks_fts_insert;
+
+--> statement-breakpoint
+DROP TRIGGER IF EXISTS tasks_fts_delete;
+
+--> statement-breakpoint
+DROP TRIGGER IF EXISTS tasks_fts_update;
+
+--> statement-breakpoint
+CREATE VIRTUAL TABLE IF NOT EXISTS tasks_fts USING fts5(
+  id, title, description,
+  tokenize='unicode61 remove_diacritics 2'
+);
+
+--> statement-breakpoint
+CREATE TRIGGER IF NOT EXISTS tasks_fts_insert AFTER INSERT ON tasks BEGIN
+  INSERT INTO tasks_fts (id, title, description)
+  VALUES (NEW.id, NEW.title, COALESCE(NEW.description, ''));
+END;
+
+--> statement-breakpoint
+CREATE TRIGGER IF NOT EXISTS tasks_fts_delete AFTER DELETE ON tasks BEGIN
+  DELETE FROM tasks_fts WHERE id = OLD.id;
+END;
+
+--> statement-breakpoint
+CREATE TRIGGER IF NOT EXISTS tasks_fts_update AFTER UPDATE ON tasks BEGIN
+  UPDATE tasks_fts 
+  SET title = NEW.title, description = COALESCE(NEW.description, '')
+  WHERE id = OLD.id;
+END;
+
+--> statement-breakpoint
+INSERT INTO tasks_fts (id, title, description)
+SELECT id, title, COALESCE(description, '') FROM tasks
+WHERE NOT EXISTS (SELECT 1 FROM tasks_fts LIMIT 1);
+`;
+var init_0003_fix_fts_compatibility = () => {};
+
+// drizzle/0004_board_scoped_ids.sql
+var _0004_board_scoped_ids_default = `ALTER TABLE tasks ADD COLUMN board_task_id INTEGER;
+
+--> statement-breakpoint
+
+ALTER TABLE boards ADD COLUMN max_board_task_id INTEGER NOT NULL DEFAULT 0;
+
+--> statement-breakpoint
+
+WITH ranked AS (
+  SELECT 
+    t.id,
+    ROW_NUMBER() OVER (
+      PARTITION BY c.board_id 
+      ORDER BY t.created_at, t.id
+    ) as rn
+  FROM tasks t
+  JOIN columns c ON t.column_id = c.id
+)
+UPDATE tasks 
+SET board_task_id = (SELECT rn FROM ranked WHERE ranked.id = tasks.id);
+
+--> statement-breakpoint
+
+UPDATE boards SET max_board_task_id = (
+  SELECT COALESCE(MAX(t.board_task_id), 0)
+  FROM tasks t
+  JOIN columns c ON t.column_id = c.id
+  WHERE c.board_id = boards.id
+);
+`;
+var init_0004_board_scoped_ids = () => {};
+
+// drizzle/0005_audit_log.sql
+var _0005_audit_log_default = `-- Add updated_by column to tasks for actor tracking
+ALTER TABLE tasks ADD COLUMN updated_by TEXT;
+
+--> statement-breakpoint
+
+-- Create audits table
+CREATE TABLE audits (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  timestamp INTEGER NOT NULL DEFAULT (unixepoch()),
+  event_type TEXT NOT NULL CHECK (event_type IN ('CREATE', 'UPDATE', 'DELETE')),
+  object_type TEXT NOT NULL CHECK (object_type IN ('task', 'column', 'board')),
+  object_id TEXT NOT NULL,
+  field_name TEXT,
+  old_value TEXT,
+  new_value TEXT,
+  actor TEXT
+);
+
+--> statement-breakpoint
+
+CREATE INDEX idx_audits_object ON audits(object_type, object_id);
+
+--> statement-breakpoint
+
+CREATE INDEX idx_audits_timestamp ON audits(timestamp);
+
+--> statement-breakpoint
+
+-- Trigger: task INSERT
+CREATE TRIGGER audit_task_insert
+AFTER INSERT ON tasks
+BEGIN
+  INSERT INTO audits (event_type, object_type, object_id, new_value, actor)
+  VALUES ('CREATE', 'task', NEW.id, 
+    json_object('title', NEW.title, 'columnId', NEW.column_id),
+    NEW.created_by);
+END;
+
+--> statement-breakpoint
+
+-- Trigger: task UPDATE (single trigger with conditional inserts for each field)
+CREATE TRIGGER audit_task_update
+AFTER UPDATE ON tasks
+BEGIN
+  -- Title changed
+  INSERT INTO audits (event_type, object_type, object_id, field_name, old_value, new_value, actor)
+  SELECT 'UPDATE', 'task', OLD.id, 'title', OLD.title, NEW.title, NEW.updated_by
+  WHERE (OLD.title IS NULL AND NEW.title IS NOT NULL)
+     OR (OLD.title IS NOT NULL AND NEW.title IS NULL)
+     OR (OLD.title <> NEW.title);
+  
+  -- Column changed (task moved)
+  INSERT INTO audits (event_type, object_type, object_id, field_name, old_value, new_value, actor)
+  SELECT 'UPDATE', 'task', OLD.id, 'columnId', OLD.column_id, NEW.column_id, NEW.updated_by
+  WHERE (OLD.column_id IS NULL AND NEW.column_id IS NOT NULL)
+     OR (OLD.column_id IS NOT NULL AND NEW.column_id IS NULL)
+     OR (OLD.column_id <> NEW.column_id);
+  
+  -- Assigned to changed
+  INSERT INTO audits (event_type, object_type, object_id, field_name, old_value, new_value, actor)
+  SELECT 'UPDATE', 'task', OLD.id, 'assignedTo', OLD.assigned_to, NEW.assigned_to, NEW.updated_by
+  WHERE (OLD.assigned_to IS NULL AND NEW.assigned_to IS NOT NULL)
+     OR (OLD.assigned_to IS NOT NULL AND NEW.assigned_to IS NULL)
+     OR (OLD.assigned_to <> NEW.assigned_to);
+
+  -- Description changed
+  INSERT INTO audits (event_type, object_type, object_id, field_name, old_value, new_value, actor)
+  SELECT 'UPDATE', 'task', OLD.id, 'description', OLD.description, NEW.description, NEW.updated_by
+  WHERE (OLD.description IS NULL AND NEW.description IS NOT NULL)
+     OR (OLD.description IS NOT NULL AND NEW.description IS NULL)
+     OR (OLD.description <> NEW.description);
+
+  -- Archived status changed
+  INSERT INTO audits (event_type, object_type, object_id, field_name, old_value, new_value, actor)
+  SELECT 'UPDATE', 'task', OLD.id, 'archived', OLD.archived, NEW.archived, NEW.updated_by
+  WHERE (OLD.archived IS NULL AND NEW.archived IS NOT NULL)
+     OR (OLD.archived IS NOT NULL AND NEW.archived IS NULL)
+     OR (OLD.archived <> NEW.archived);
+
+  -- Labels changed
+  INSERT INTO audits (event_type, object_type, object_id, field_name, old_value, new_value, actor)
+  SELECT 'UPDATE', 'task', OLD.id, 'labels', OLD.labels, NEW.labels, NEW.updated_by
+  WHERE (OLD.labels IS NULL AND NEW.labels IS NOT NULL)
+     OR (OLD.labels IS NOT NULL AND NEW.labels IS NULL)
+     OR (OLD.labels <> NEW.labels);
+END;
+
+--> statement-breakpoint
+
+-- Trigger: task DELETE
+CREATE TRIGGER audit_task_delete
+AFTER DELETE ON tasks
+BEGIN
+  INSERT INTO audits (event_type, object_type, object_id, old_value)
+  VALUES ('DELETE', 'task', OLD.id,
+    json_object('title', OLD.title, 'columnId', OLD.column_id));
+END;
+`;
+var init_0005_audit_log = () => {};
+
+// drizzle/0006_due_date.sql
+var _0006_due_date_default = `ALTER TABLE tasks ADD COLUMN due_date INTEGER;
+`;
+var init_0006_due_date = () => {};
+
+// drizzle/0007_task_links.sql
+var _0007_task_links_default = `-- Create task_links table
+CREATE TABLE task_links (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  from_task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+  to_task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+  link_type TEXT NOT NULL CHECK (link_type IN ('blocks', 'blocked_by', 'related')),
+  created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+  UNIQUE(from_task_id, to_task_id, link_type)
+);
+
+--> statement-breakpoint
+
+CREATE INDEX idx_task_links_from ON task_links(from_task_id);
+
+--> statement-breakpoint
+
+CREATE INDEX idx_task_links_to ON task_links(to_task_id);
+
+--> statement-breakpoint
+
+CREATE INDEX idx_task_links_type ON task_links(link_type);
+`;
+var init_0007_task_links = () => {};
+
 // src/db/migrator.ts
 var exports_migrator = {};
 __export(exports_migrator, {
@@ -220,7 +491,7 @@ import { readFileSync } from "node:fs";
 import { dirname as dirname2, isAbsolute, join } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function resolveSqlContent(sqlOrPath) {
-  if (sqlOrPath.includes("CREATE") || sqlOrPath.includes("INSERT") || sqlOrPath.includes("--")) {
+  if (sqlOrPath.includes("CREATE") || sqlOrPath.includes("INSERT") || sqlOrPath.includes("ALTER") || sqlOrPath.includes("--")) {
     return sqlOrPath;
   }
   let filePath = sqlOrPath;
@@ -327,10 +598,20 @@ var init_migrator = __esm(() => {
   init_0000_init();
   init_0001_add_archived();
   init_0002_add_fts5();
+  init_0003_fix_fts_compatibility();
+  init_0004_board_scoped_ids();
+  init_0005_audit_log();
+  init_0006_due_date();
+  init_0007_task_links();
   migrationSql = {
     "0000_init": _0000_init_default,
     "0001_add_archived": _0001_add_archived_default,
-    "0002_add_fts5": _0002_add_fts5_default
+    "0002_add_fts5": _0002_add_fts5_default,
+    "0003_fix_fts_compatibility": _0003_fix_fts_compatibility_default,
+    "0004_board_scoped_ids": _0004_board_scoped_ids_default,
+    "0005_audit_log": _0005_audit_log_default,
+    "0006_due_date": _0006_due_date_default,
+    "0007_task_links": _0007_task_links_default
   };
   __dirname2 = dirname2(fileURLToPath2(import.meta.url));
   drizzleDir = join(__dirname2, "..", "..", "drizzle");
@@ -386,17 +667,174 @@ var init_libsql_adapter = __esm(() => {
   init_utils();
 });
 
+// src/db/recovery.ts
+import { existsSync as existsSync2, renameSync, unlinkSync } from "node:fs";
+import { execSync } from "node:child_process";
+function checkIntegrity(db) {
+  try {
+    const result = db.query("PRAGMA integrity_check").get();
+    return result?.integrity_check === "ok";
+  } catch {
+    return false;
+  }
+}
+function attemptWalRecovery(db) {
+  try {
+    db.query("PRAGMA wal_checkpoint(TRUNCATE)").get();
+    return checkIntegrity(db);
+  } catch {
+    return false;
+  }
+}
+function dumpAndRestore(dbPath) {
+  const backupPath = `${dbPath}.corrupted.${Date.now()}`;
+  const dumpPath = `${dbPath}.dump.sql`;
+  try {
+    execSync(`sqlite3 "${dbPath}" ".dump" > "${dumpPath}" 2>/dev/null`, {
+      encoding: "utf-8",
+      timeout: 30000
+    });
+    renameSync(dbPath, backupPath);
+    const walPath = `${dbPath}-wal`;
+    const shmPath = `${dbPath}-shm`;
+    if (existsSync2(walPath))
+      unlinkSync(walPath);
+    if (existsSync2(shmPath))
+      unlinkSync(shmPath);
+    execSync(`sqlite3 "${dbPath}" < "${dumpPath}"`, {
+      encoding: "utf-8",
+      timeout: 30000
+    });
+    unlinkSync(dumpPath);
+    return { success: true, backupPath };
+  } catch {
+    try {
+      if (existsSync2(dumpPath))
+        unlinkSync(dumpPath);
+      if (existsSync2(backupPath) && !existsSync2(dbPath)) {
+        renameSync(backupPath, dbPath);
+      }
+    } catch {}
+    return { success: false, backupPath };
+  }
+}
+function rebuildFts(db) {
+  try {
+    db.run("DROP TABLE IF EXISTS tasks_fts");
+    db.run("DROP TRIGGER IF EXISTS tasks_fts_insert");
+    db.run("DROP TRIGGER IF EXISTS tasks_fts_delete");
+    db.run("DROP TRIGGER IF EXISTS tasks_fts_update");
+    db.run(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS tasks_fts USING fts5(
+        id, title, description,
+        tokenize='unicode61 remove_diacritics 2'
+      )
+    `);
+    db.run(`
+      CREATE TRIGGER IF NOT EXISTS tasks_fts_insert AFTER INSERT ON tasks BEGIN
+        INSERT INTO tasks_fts (id, title, description)
+        VALUES (NEW.id, NEW.title, COALESCE(NEW.description, ''));
+      END
+    `);
+    db.run(`
+      CREATE TRIGGER IF NOT EXISTS tasks_fts_delete AFTER DELETE ON tasks BEGIN
+        DELETE FROM tasks_fts WHERE id = OLD.id;
+      END
+    `);
+    db.run(`
+      CREATE TRIGGER IF NOT EXISTS tasks_fts_update AFTER UPDATE ON tasks BEGIN
+        UPDATE tasks_fts 
+        SET title = NEW.title, description = COALESCE(NEW.description, '')
+        WHERE id = OLD.id;
+      END
+    `);
+    db.run(`
+      INSERT INTO tasks_fts (id, title, description)
+      SELECT id, title, COALESCE(description, '') FROM tasks
+    `);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkFtsHealth(db) {
+  try {
+    db.query("SELECT COUNT(*) FROM tasks_fts").get();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function attemptRecovery(dbPath, openDb) {
+  let db = null;
+  try {
+    db = openDb();
+    const integrityOk = checkIntegrity(db);
+    const ftsOk = checkFtsHealth(db);
+    if (integrityOk && ftsOk) {
+      return { recovered: false };
+    }
+    if (integrityOk && !ftsOk) {
+      console.warn("[kaban] FTS corruption detected, rebuilding...");
+      if (rebuildFts(db)) {
+        console.warn("[kaban] FTS rebuilt successfully");
+        return { recovered: true, method: "fts_rebuild" };
+      }
+    }
+    if (integrityOk) {
+      return { recovered: false };
+    }
+    console.warn("[kaban] Database corruption detected, attempting recovery...");
+    if (attemptWalRecovery(db)) {
+      console.warn("[kaban] Recovery successful via WAL checkpoint");
+      return { recovered: true, method: "wal_checkpoint" };
+    }
+    db.close();
+    db = null;
+    const { success, backupPath } = dumpAndRestore(dbPath);
+    if (success) {
+      console.warn(`[kaban] Recovery successful via dump/restore. Backup: ${backupPath}`);
+      return { recovered: true, method: "dump_restore", backupPath };
+    }
+    throw new KabanError(`Database is corrupted and automatic recovery failed. Backup at: ${backupPath}`, ExitCode.GENERAL_ERROR);
+  } finally {
+    try {
+      db?.close();
+    } catch {}
+  }
+}
+var init_recovery = __esm(() => {
+  init_types();
+});
+
 // src/db/bun-adapter.ts
 var exports_bun_adapter = {};
 __export(exports_bun_adapter, {
   createBunDb: () => createBunDb
 });
+import { existsSync as existsSync3 } from "node:fs";
 async function createBunDb(filePath) {
   let sqlite;
   try {
     const { Database } = await import("bun:sqlite");
     const { drizzle } = await import("drizzle-orm/bun-sqlite");
     ensureDbDir(filePath);
+    if (existsSync3(filePath)) {
+      const recovery = await attemptRecovery(filePath, () => {
+        const tempDb = new Database(filePath);
+        return {
+          query: (sql) => ({
+            get: () => tempDb.query(sql).get(),
+            all: () => tempDb.query(sql).all()
+          }),
+          run: (sql) => tempDb.run(sql),
+          close: () => tempDb.close()
+        };
+      });
+      if (recovery.recovered) {
+        console.warn(`[kaban] Database recovered using ${recovery.method}`);
+      }
+    }
     sqlite = new Database(filePath);
     const db = drizzle({ client: sqlite, schema: exports_schema });
     let closed = false;
@@ -437,6 +875,7 @@ async function createBunDb(filePath) {
 }
 var init_bun_adapter = __esm(() => {
   init_types();
+  init_recovery();
   init_schema();
   init_utils();
 });
@@ -510,6 +949,7 @@ PRAGMA journal_mode = WAL;
 CREATE TABLE IF NOT EXISTS boards (
   id TEXT PRIMARY KEY,
   name TEXT NOT NULL,
+  max_board_task_id INTEGER NOT NULL DEFAULT 0,
   created_at INTEGER NOT NULL,
   updated_at INTEGER NOT NULL
 );
@@ -525,6 +965,7 @@ CREATE TABLE IF NOT EXISTS columns (
 
 CREATE TABLE IF NOT EXISTS tasks (
   id TEXT PRIMARY KEY,
+  board_task_id INTEGER,
   title TEXT NOT NULL,
   description TEXT,
   column_id TEXT NOT NULL REFERENCES columns(id),
@@ -541,8 +982,10 @@ CREATE TABLE IF NOT EXISTS tasks (
   updated_at INTEGER NOT NULL,
   started_at INTEGER,
   completed_at INTEGER,
+  due_date INTEGER,
   archived INTEGER NOT NULL DEFAULT 0,
-  archived_at INTEGER
+  archived_at INTEGER,
+  updated_by TEXT
 );
 
 CREATE TABLE IF NOT EXISTS undo_log (
@@ -552,8 +995,95 @@ CREATE TABLE IF NOT EXISTS undo_log (
   created_at INTEGER NOT NULL
 );
 
+CREATE TABLE IF NOT EXISTS audits (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  timestamp INTEGER NOT NULL DEFAULT (unixepoch()),
+  event_type TEXT NOT NULL CHECK (event_type IN ('CREATE', 'UPDATE', 'DELETE')),
+  object_type TEXT NOT NULL CHECK (object_type IN ('task', 'column', 'board')),
+  object_id TEXT NOT NULL,
+  field_name TEXT,
+  old_value TEXT,
+  new_value TEXT,
+  actor TEXT
+);
+
+CREATE TABLE IF NOT EXISTS task_links (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  from_task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+  to_task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+  link_type TEXT NOT NULL CHECK (link_type IN ('blocks', 'blocked_by', 'related')),
+  created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+  UNIQUE(from_task_id, to_task_id, link_type)
+);
+
 CREATE INDEX IF NOT EXISTS idx_tasks_column ON tasks(column_id);
 CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_id);
+CREATE INDEX IF NOT EXISTS idx_audits_object ON audits(object_type, object_id);
+CREATE INDEX IF NOT EXISTS idx_audits_timestamp ON audits(timestamp);
+CREATE INDEX IF NOT EXISTS idx_audits_actor ON audits(actor);
+CREATE INDEX IF NOT EXISTS idx_task_links_from ON task_links(from_task_id);
+CREATE INDEX IF NOT EXISTS idx_task_links_to ON task_links(to_task_id);
+CREATE INDEX IF NOT EXISTS idx_task_links_type ON task_links(link_type);
+
+-- Trigger: task INSERT
+CREATE TRIGGER IF NOT EXISTS audit_task_insert
+AFTER INSERT ON tasks
+BEGIN
+  INSERT INTO audits (event_type, object_type, object_id, new_value, actor)
+  VALUES ('CREATE', 'task', NEW.id, 
+    json_object('title', NEW.title, 'columnId', NEW.column_id),
+    NEW.created_by);
+END;
+
+-- Trigger: task UPDATE
+CREATE TRIGGER IF NOT EXISTS audit_task_update
+AFTER UPDATE ON tasks
+BEGIN
+  INSERT INTO audits (event_type, object_type, object_id, field_name, old_value, new_value, actor)
+  SELECT 'UPDATE', 'task', OLD.id, 'title', OLD.title, NEW.title, NEW.updated_by
+  WHERE (OLD.title IS NULL AND NEW.title IS NOT NULL)
+     OR (OLD.title IS NOT NULL AND NEW.title IS NULL)
+     OR (OLD.title <> NEW.title);
+  
+  INSERT INTO audits (event_type, object_type, object_id, field_name, old_value, new_value, actor)
+  SELECT 'UPDATE', 'task', OLD.id, 'columnId', OLD.column_id, NEW.column_id, NEW.updated_by
+  WHERE (OLD.column_id IS NULL AND NEW.column_id IS NOT NULL)
+     OR (OLD.column_id IS NOT NULL AND NEW.column_id IS NULL)
+     OR (OLD.column_id <> NEW.column_id);
+  
+  INSERT INTO audits (event_type, object_type, object_id, field_name, old_value, new_value, actor)
+  SELECT 'UPDATE', 'task', OLD.id, 'assignedTo', OLD.assigned_to, NEW.assigned_to, NEW.updated_by
+  WHERE (OLD.assigned_to IS NULL AND NEW.assigned_to IS NOT NULL)
+     OR (OLD.assigned_to IS NOT NULL AND NEW.assigned_to IS NULL)
+     OR (OLD.assigned_to <> NEW.assigned_to);
+
+  INSERT INTO audits (event_type, object_type, object_id, field_name, old_value, new_value, actor)
+  SELECT 'UPDATE', 'task', OLD.id, 'description', OLD.description, NEW.description, NEW.updated_by
+  WHERE (OLD.description IS NULL AND NEW.description IS NOT NULL)
+     OR (OLD.description IS NOT NULL AND NEW.description IS NULL)
+     OR (OLD.description <> NEW.description);
+
+  INSERT INTO audits (event_type, object_type, object_id, field_name, old_value, new_value, actor)
+  SELECT 'UPDATE', 'task', OLD.id, 'archived', OLD.archived, NEW.archived, NEW.updated_by
+  WHERE (OLD.archived IS NULL AND NEW.archived IS NOT NULL)
+     OR (OLD.archived IS NOT NULL AND NEW.archived IS NULL)
+     OR (OLD.archived <> NEW.archived);
+
+  INSERT INTO audits (event_type, object_type, object_id, field_name, old_value, new_value, actor)
+  SELECT 'UPDATE', 'task', OLD.id, 'labels', OLD.labels, NEW.labels, NEW.updated_by
+  WHERE (OLD.labels IS NULL AND NEW.labels IS NOT NULL)
+     OR (OLD.labels IS NOT NULL AND NEW.labels IS NULL)
+     OR (OLD.labels <> NEW.labels);
+END;
+
+-- Trigger: task DELETE
+CREATE TRIGGER IF NOT EXISTS audit_task_delete
+AFTER DELETE ON tasks
+BEGIN
+  INSERT INTO audits (event_type, object_type, object_id, old_value)
+  VALUES ('DELETE', 'task', OLD.id,
+    json_object('title', OLD.title, 'columnId', OLD.column_id));
+END;
 `;
 async function initializeSchema(db) {
   await db.$runRaw(SCHEMA_SQL);
@@ -569,6 +1099,7 @@ var AgentNameSchema = AgentNameBaseSchema.transform((s) => s.toLowerCase());
 var ColumnIdSchema = z.string().min(1, "Column ID cannot be empty").max(50, "Column ID cannot exceed 50 characters").regex(/^[a-z0-9_]+$/, "Column ID must be lowercase alphanumeric with underscores");
 var TaskSchema = z.object({
   id: UlidSchema,
+  boardTaskId: z.number().int().positive().nullable(),
   title: z.string(),
   description: z.string().nullable(),
   columnId: z.string(),
@@ -585,8 +1116,29 @@ var TaskSchema = z.object({
   updatedAt: z.date(),
   startedAt: z.date().nullable(),
   completedAt: z.date().nullable(),
+  dueDate: z.date().nullable(),
   archived: z.boolean().default(false),
-  archivedAt: z.date().nullable().optional()
+  archivedAt: z.date().nullable().optional(),
+  updatedBy: z.string().nullable()
+});
+var AuditSchema = z.object({
+  id: z.number().int().positive(),
+  timestamp: z.date(),
+  eventType: z.enum(["CREATE", "UPDATE", "DELETE"]),
+  objectType: z.enum(["task", "column", "board"]),
+  objectId: z.string(),
+  fieldName: z.string().nullable(),
+  oldValue: z.string().nullable(),
+  newValue: z.string().nullable(),
+  actor: z.string().nullable()
+});
+var LinkTypeSchema = z.enum(["blocks", "blocked_by", "related"]);
+var TaskLinkSchema = z.object({
+  id: z.number().int().positive(),
+  fromTaskId: UlidSchema,
+  toTaskId: UlidSchema,
+  linkType: LinkTypeSchema,
+  createdAt: z.date()
 });
 var ColumnSchema = z.object({
   id: z.string(),
@@ -598,6 +1150,7 @@ var ColumnSchema = z.object({
 var BoardSchema = z.object({
   id: UlidSchema,
   name: z.string(),
+  maxBoardTaskId: z.number().int().nonnegative(),
   createdAt: z.date(),
   updatedAt: z.date()
 });
@@ -632,14 +1185,16 @@ var AddTaskInputSchema = z.object({
   assignedTo: AgentNameSchema.optional(),
   dependsOn: z.array(UlidSchema).optional(),
   files: z.array(z.string()).optional(),
-  labels: z.array(z.string().max(50)).optional()
+  labels: z.array(z.string().max(50)).optional(),
+  dueDate: z.string().optional()
 });
 var UpdateTaskInputSchema = z.object({
   title: TitleSchema.optional(),
   description: z.string().max(5000).nullable().optional(),
   assignedTo: AgentNameSchema.nullable().optional(),
   files: z.array(z.string()).optional(),
-  labels: z.array(z.string().max(50)).optional()
+  labels: z.array(z.string().max(50)).optional(),
+  dueDate: z.string().nullable().optional()
 });
 var MoveTaskInputSchema = z.object({
   id: UlidSchema,
@@ -665,6 +1220,7 @@ var TaskResponseSchema = TaskSchema.extend({
   updatedAt: z.string().datetime(),
   startedAt: z.string().datetime().nullable(),
   completedAt: z.string().datetime().nullable(),
+  dueDate: z.string().datetime().nullable(),
   archivedAt: z.string().datetime().nullable().optional()
 });
 var BoardStatusSchema = z.object({
@@ -691,14 +1247,16 @@ var AddTaskInputJsonSchema = z.object({
   assignedTo: AgentNameBaseSchema.optional(),
   dependsOn: z.array(UlidSchema).optional(),
   files: z.array(z.string()).optional(),
-  labels: z.array(z.string().max(50)).optional()
+  labels: z.array(z.string().max(50)).optional(),
+  dueDate: z.string().optional()
 });
 var UpdateTaskInputJsonSchema = z.object({
   title: TitleBaseSchema.optional(),
   description: z.string().max(5000).nullable().optional(),
   assignedTo: AgentNameBaseSchema.nullable().optional(),
   files: z.array(z.string()).optional(),
-  labels: z.array(z.string().max(50)).optional()
+  labels: z.array(z.string().max(50)).optional(),
+  dueDate: z.string().nullable().optional()
 });
 var ListTasksFilterJsonSchema = z.object({
   columnId: ColumnIdSchema.optional(),
@@ -738,9 +1296,103 @@ var jsonSchemas = {
 function getJsonSchema(name) {
   return jsonSchemas[name];
 }
+// src/services/audit.ts
+init_schema();
+import { and, desc, eq, gte, isNotNull, lte, sql } from "drizzle-orm";
+
+class AuditService {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async getHistory(filter = {}) {
+    const conditions = [];
+    if (filter.objectType) {
+      conditions.push(eq(audits.objectType, filter.objectType));
+    }
+    if (filter.objectId) {
+      conditions.push(eq(audits.objectId, filter.objectId));
+    }
+    if (filter.eventType) {
+      conditions.push(eq(audits.eventType, filter.eventType));
+    }
+    if (filter.actor) {
+      conditions.push(eq(audits.actor, filter.actor));
+    }
+    if (filter.since) {
+      conditions.push(gte(audits.timestamp, filter.since));
+    }
+    if (filter.until) {
+      conditions.push(lte(audits.timestamp, filter.until));
+    }
+    const limit = Math.min(filter.limit ?? 50, 1000);
+    const offset = filter.offset ?? 0;
+    const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
+    const entries = await this.db.select().from(audits).where(whereClause).orderBy(desc(audits.timestamp)).limit(limit + 1).offset(offset);
+    const hasMore = entries.length > limit;
+    if (hasMore)
+      entries.pop();
+    const countResult = await this.db.select({ count: sql`COUNT(*)` }).from(audits).where(whereClause);
+    return {
+      entries,
+      total: countResult[0]?.count ?? 0,
+      hasMore
+    };
+  }
+  async getTaskHistory(taskId, limit = 50) {
+    const result = await this.getHistory({
+      objectType: "task",
+      objectId: taskId,
+      limit
+    });
+    return result.entries;
+  }
+  async getRecentChanges(limit = 50) {
+    const result = await this.getHistory({ limit });
+    return result.entries;
+  }
+  async getChangesByActor(actor, limit = 50) {
+    const result = await this.getHistory({ actor, limit });
+    return result.entries;
+  }
+  async getStats() {
+    const total = await this.db.select({ count: sql`COUNT(*)` }).from(audits);
+    const byEvent = await this.db.select({
+      eventType: audits.eventType,
+      count: sql`COUNT(*)`
+    }).from(audits).groupBy(audits.eventType);
+    const byObject = await this.db.select({
+      objectType: audits.objectType,
+      count: sql`COUNT(*)`
+    }).from(audits).groupBy(audits.objectType);
+    const recentActors = await this.db.selectDistinct({ actor: audits.actor }).from(audits).where(isNotNull(audits.actor)).orderBy(desc(audits.timestamp)).limit(10);
+    const byEventType = {
+      CREATE: 0,
+      UPDATE: 0,
+      DELETE: 0
+    };
+    for (const e of byEvent) {
+      byEventType[e.eventType] = e.count;
+    }
+    const byObjectType = {
+      task: 0,
+      column: 0,
+      board: 0
+    };
+    for (const o of byObject) {
+      byObjectType[o.objectType] = o.count;
+    }
+    return {
+      totalEntries: total[0]?.count ?? 0,
+      byEventType,
+      byObjectType,
+      recentActors: recentActors.map((a) => a.actor).filter((a) => a !== null)
+    };
+  }
+}
 // src/services/board.ts
 init_schema();
-import { eq } from "drizzle-orm";
+import { eq as eq2 } from "drizzle-orm";
 import { ulid } from "ulid";
 
 class BoardService {
@@ -771,6 +1423,7 @@ class BoardService {
     return {
       id: boardId,
       name: config.board.name,
+      maxBoardTaskId: 0,
       createdAt: now,
       updatedAt: now
     };
@@ -783,23 +1436,493 @@ class BoardService {
     return this.db.select().from(columns).orderBy(columns.position);
   }
   async getColumn(id) {
-    const rows = await this.db.select().from(columns).where(eq(columns.id, id));
+    const rows = await this.db.select().from(columns).where(eq2(columns.id, id));
     return rows[0] ?? null;
   }
   async getTerminalColumn() {
-    const rows = await this.db.select().from(columns).where(eq(columns.isTerminal, true));
+    const rows = await this.db.select().from(columns).where(eq2(columns.isTerminal, true));
     return rows[0] ?? null;
   }
   async getTerminalColumns() {
-    return this.db.select().from(columns).where(eq(columns.isTerminal, true)).orderBy(columns.position);
+    return this.db.select().from(columns).where(eq2(columns.isTerminal, true)).orderBy(columns.position);
+  }
+}
+// src/services/dependency.ts
+class DependencyService {
+  getTask;
+  constructor(getTask) {
+    this.getTask = getTask;
+  }
+  async wouldCreateCycle(taskId, dependsOnId) {
+    if (taskId === dependsOnId) {
+      return { hasCycle: true, cyclePath: [taskId, taskId] };
+    }
+    const visited = new Set;
+    const path = [];
+    const dfs = async (currentId) => {
+      if (currentId === taskId) {
+        path.push(currentId);
+        return true;
+      }
+      if (visited.has(currentId)) {
+        return false;
+      }
+      visited.add(currentId);
+      path.push(currentId);
+      const task = await this.getTask(currentId);
+      if (!task?.dependsOn?.length) {
+        path.pop();
+        return false;
+      }
+      for (const depId of task.dependsOn) {
+        if (await dfs(depId)) {
+          return true;
+        }
+      }
+      path.pop();
+      return false;
+    };
+    const hasCycle = await dfs(dependsOnId);
+    if (hasCycle) {
+      return { hasCycle: true, cyclePath: [taskId, ...path] };
+    }
+    return { hasCycle: false };
+  }
+  formatCyclePath(path, getShortId) {
+    return path.map((id) => {
+      const shortId = getShortId?.(id);
+      return shortId ? `#${shortId}` : id.slice(0, 8);
+    }).join(" → ");
   }
 }
+// src/services/link.ts
+init_schema();
+init_types();
+import { and as and2, eq as eq3, or } from "drizzle-orm";
+
+class LinkService {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async addLink(fromTaskId, toTaskId, type) {
+    if (fromTaskId === toTaskId) {
+      throw new KabanError("Task cannot link to itself", ExitCode.VALIDATION);
+    }
+    const now = new Date;
+    await this.db.insert(taskLinks).values({
+      fromTaskId,
+      toTaskId,
+      linkType: type,
+      createdAt: now
+    }).onConflictDoNothing();
+    if (type === "blocks") {
+      await this.db.insert(taskLinks).values({
+        fromTaskId: toTaskId,
+        toTaskId: fromTaskId,
+        linkType: "blocked_by",
+        createdAt: now
+      }).onConflictDoNothing();
+    } else if (type === "blocked_by") {
+      await this.db.insert(taskLinks).values({
+        fromTaskId: toTaskId,
+        toTaskId: fromTaskId,
+        linkType: "blocks",
+        createdAt: now
+      }).onConflictDoNothing();
+    }
+    const result = await this.db.select().from(taskLinks).where(and2(eq3(taskLinks.fromTaskId, fromTaskId), eq3(taskLinks.toTaskId, toTaskId), eq3(taskLinks.linkType, type))).limit(1);
+    return result[0];
+  }
+  async removeLink(fromTaskId, toTaskId, type) {
+    await this.db.delete(taskLinks).where(and2(eq3(taskLinks.fromTaskId, fromTaskId), eq3(taskLinks.toTaskId, toTaskId), eq3(taskLinks.linkType, type)));
+    if (type === "blocks") {
+      await this.db.delete(taskLinks).where(and2(eq3(taskLinks.fromTaskId, toTaskId), eq3(taskLinks.toTaskId, fromTaskId), eq3(taskLinks.linkType, "blocked_by")));
+    } else if (type === "blocked_by") {
+      await this.db.delete(taskLinks).where(and2(eq3(taskLinks.fromTaskId, toTaskId), eq3(taskLinks.toTaskId, fromTaskId), eq3(taskLinks.linkType, "blocks")));
+    }
+  }
+  async getLinksFrom(taskId, type) {
+    if (type) {
+      return this.db.select().from(taskLinks).where(and2(eq3(taskLinks.fromTaskId, taskId), eq3(taskLinks.linkType, type)));
+    }
+    return this.db.select().from(taskLinks).where(eq3(taskLinks.fromTaskId, taskId));
+  }
+  async getLinksTo(taskId, type) {
+    if (type) {
+      return this.db.select().from(taskLinks).where(and2(eq3(taskLinks.toTaskId, taskId), eq3(taskLinks.linkType, type)));
+    }
+    return this.db.select().from(taskLinks).where(eq3(taskLinks.toTaskId, taskId));
+  }
+  async getAllLinks(taskId) {
+    return this.db.select().from(taskLinks).where(or(eq3(taskLinks.fromTaskId, taskId), eq3(taskLinks.toTaskId, taskId)));
+  }
+  async getBlockers(taskId) {
+    const links = await this.getLinksFrom(taskId, "blocked_by");
+    return links.map((l) => l.toTaskId);
+  }
+  async getBlocking(taskId) {
+    const links = await this.getLinksFrom(taskId, "blocks");
+    return links.map((l) => l.toTaskId);
+  }
+}
+// src/services/markdown.ts
+class MarkdownService {
+  exportBoard(board, columns2, tasksByColumn, options) {
+    const lines = [];
+    lines.push(`# ${escapeMarkdown(board.name)}`);
+    lines.push("");
+    const sortedColumns = [...columns2].sort((a, b) => a.position - b.position);
+    for (const column of sortedColumns) {
+      lines.push(`## ${escapeMarkdown(column.name)}`);
+      if (column.wipLimit !== null) {
+        lines.push(`<!-- WIP Limit: ${column.wipLimit} -->`);
+      }
+      if (column.isTerminal) {
+        lines.push(`<!-- Terminal column -->`);
+      }
+      lines.push("");
+      const tasks2 = tasksByColumn.get(column.id) || [];
+      const sortedTasks = [...tasks2].sort((a, b) => a.position - b.position);
+      for (const task of sortedTasks) {
+        if (!options?.includeArchived && task.archived)
+          continue;
+        if (options?.includeMetadata) {
+          lines.push(`- ${escapeMarkdown(task.title)} <!-- id:${task.id} -->`);
+        } else {
+          lines.push(`- ${escapeMarkdown(task.title)}`);
+        }
+        if (task.dueDate) {
+          const checkmark = task.completedAt ? " ✓" : "";
+          lines.push(`    @ ${formatDate(task.dueDate)}${checkmark}`);
+        }
+        if (task.labels && task.labels.length > 0) {
+          lines.push(`    # ${task.labels.join(", ")}`);
+        }
+        if (task.assignedTo) {
+          lines.push(`    @ assigned: ${task.assignedTo}`);
+        }
+        if (task.description) {
+          const descLines = task.description.split(`
+`);
+          for (const line of descLines) {
+            lines.push(`    > ${escapeMarkdown(line)}`);
+          }
+        }
+        lines.push("");
+      }
+    }
+    return lines.join(`
+`).trimEnd() + `
+`;
+  }
+  parseMarkdown(content) {
+    const lines = content.split(`
+`);
+    const errors = [];
+    let boardName = "Imported Board";
+    const columns2 = [];
+    let currentColumn = null;
+    let currentTask = null;
+    for (let i = 0;i < lines.length; i++) {
+      const line = lines[i];
+      const lineNum = i + 1;
+      if (line.startsWith("# ") && !line.startsWith("## ")) {
+        boardName = unescapeMarkdown(line.slice(2).trim());
+        continue;
+      }
+      if (line.startsWith("## ")) {
+        if (currentTask && currentColumn) {
+          currentColumn.tasks.push(currentTask);
+          currentTask = null;
+        }
+        if (currentColumn) {
+          columns2.push(currentColumn);
+        }
+        currentColumn = {
+          name: unescapeMarkdown(line.slice(3).trim()),
+          tasks: []
+        };
+        continue;
+      }
+      if (line.includes("WIP Limit:") && currentColumn) {
+        const match = line.match(/WIP Limit:\s*(\d+|none)/i);
+        if (match) {
+          currentColumn.wipLimit = match[1].toLowerCase() === "none" ? undefined : parseInt(match[1], 10);
+        }
+        continue;
+      }
+      if (line.includes("Terminal column") && currentColumn) {
+        currentColumn.isTerminal = true;
+        continue;
+      }
+      if (line.startsWith("- ")) {
+        if (currentTask && currentColumn) {
+          currentColumn.tasks.push(currentTask);
+        }
+        let title = line.slice(2);
+        let id;
+        const idMatch = title.match(/<!--\s*id:([^\s]+)\s*-->/);
+        if (idMatch) {
+          id = idMatch[1];
+          title = title.replace(idMatch[0], "").trim();
+        }
+        currentTask = {
+          title: unescapeMarkdown(title),
+          id,
+          description: null,
+          dueDate: null,
+          labels: []
+        };
+        continue;
+      }
+      const indentMatch = line.match(/^(\s{4}|\t)/);
+      if (indentMatch && currentTask) {
+        const content2 = line.slice(indentMatch[0].length);
+        if (content2.startsWith("@ ") && !content2.includes("assigned:")) {
+          const dueLine = content2.slice(2).trim();
+          const dateStr = dueLine.replace("✓", "").trim();
+          const parsed = parseISODate(dateStr);
+          if (parsed) {
+            currentTask.dueDate = parsed;
+          } else {
+            errors.push(`Line ${lineNum}: Invalid date format "${dateStr}"`);
+          }
+          continue;
+        }
+        if (content2.includes("assigned:")) {
+          const match = content2.match(/assigned:\s*(\S+)/);
+          if (match) {
+            currentTask.assignedTo = match[1];
+          }
+          continue;
+        }
+        if (content2.startsWith("# ")) {
+          const labelStr = content2.slice(2).trim();
+          currentTask.labels = labelStr.split(",").map((l) => l.trim()).filter(Boolean);
+          continue;
+        }
+        if (content2.startsWith("> ")) {
+          const descLine = unescapeMarkdown(content2.slice(2));
+          if (currentTask.description === null) {
+            currentTask.description = descLine;
+          } else {
+            currentTask.description += `
+` + descLine;
+          }
+          continue;
+        }
+      }
+    }
+    if (currentTask && currentColumn) {
+      currentColumn.tasks.push(currentTask);
+    }
+    if (currentColumn) {
+      columns2.push(currentColumn);
+    }
+    return { boardName, columns: columns2, errors };
+  }
+}
+function escapeMarkdown(text2) {
+  return text2.replace(/\\/g, "\\\\").replace(/\n/g, " ").replace(/<!--/g, "\\<!--");
+}
+function unescapeMarkdown(text2) {
+  return text2.replace(/\\<!--/g, "<!--").replace(/\\\\/g, "\\");
+}
+function formatDate(date) {
+  return date.toISOString().split("T")[0];
+}
+function parseISODate(str) {
+  const match = str.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (!match)
+    return null;
+  const date = new Date(str + "T00:00:00.000Z");
+  if (isNaN(date.getTime()))
+    return null;
+  return date;
+}
+// src/services/scoring/scorers/fifo.ts
+var fifoScorer = {
+  name: "fifo",
+  description: "First In, First Out - oldest tasks scored higher",
+  units: "age",
+  async score(task) {
+    const ageMs = Date.now() - task.createdAt.getTime();
+    const ageDays = ageMs / (1000 * 60 * 60 * 24);
+    return ageDays;
+  }
+};
+// src/services/scoring/scorers/priority.ts
+var PRIORITY_WEIGHTS = {
+  critical: 1000,
+  urgent: 500,
+  high: 100,
+  medium: 50,
+  low: 10,
+  p0: 1000,
+  p1: 500,
+  p2: 100,
+  p3: 50,
+  p4: 10
+};
+var priorityScorer = {
+  name: "priority",
+  description: "Score based on priority labels (critical, urgent, high, p0-p4)",
+  units: "priority",
+  async score(task) {
+    let maxPriority = 0;
+    for (const label of task.labels) {
+      const weight = PRIORITY_WEIGHTS[label.toLowerCase()];
+      if (weight && weight > maxPriority) {
+        maxPriority = weight;
+      }
+    }
+    return maxPriority;
+  }
+};
+// src/services/scoring/scorers/due-date.ts
+var dueDateScorer = {
+  name: "due-date",
+  description: "Score based on due date urgency (closer/overdue = higher)",
+  units: "urgency",
+  async score(task) {
+    if (!task.dueDate) {
+      return 0;
+    }
+    const now = Date.now();
+    const dueTime = task.dueDate.getTime();
+    const daysUntilDue = (dueTime - now) / (1000 * 60 * 60 * 24);
+    if (daysUntilDue <= 0) {
+      return 1000 + Math.abs(daysUntilDue) * 10;
+    }
+    if (daysUntilDue <= 1) {
+      return 500;
+    }
+    if (daysUntilDue <= 7) {
+      return 100 + (7 - daysUntilDue) * 10;
+    }
+    return Math.max(0, 50 - daysUntilDue);
+  }
+};
+// src/services/scoring/scorers/blocking.ts
+function createBlockingScorer(getBlockingCount) {
+  return {
+    name: "blocking",
+    description: "Score based on how many tasks this blocks",
+    units: "blocked",
+    async score(task) {
+      const blockingCount = await getBlockingCount(task.id);
+      return blockingCount * 50;
+    }
+  };
+}
+
+// src/services/scoring/index.ts
+class ScoringService {
+  scorers = [];
+  addScorer(scorer) {
+    this.scorers.push(scorer);
+  }
+  removeScorer(name) {
+    this.scorers = this.scorers.filter((s) => s.name !== name);
+  }
+  getScorers() {
+    return [...this.scorers];
+  }
+  async scoreTask(task) {
+    const breakdown = {};
+    let totalScore = 0;
+    for (const scorer of this.scorers) {
+      const score = await scorer.score(task);
+      breakdown[scorer.name] = score;
+      totalScore += score;
+    }
+    return {
+      task,
+      score: totalScore,
+      breakdown
+    };
+  }
+  async rankTasks(tasks2) {
+    const scored = await Promise.all(tasks2.map((task) => this.scoreTask(task)));
+    return scored.sort((a, b) => b.score - a.score);
+  }
+}
+function createDefaultScoringService() {
+  return new ScoringService;
+}
 // src/services/task.ts
 init_schema();
 init_types();
-import { and, eq as eq2, inArray, lt, sql } from "drizzle-orm";
+import { and as and3, eq as eq4, inArray, lt, sql as sql2 } from "drizzle-orm";
 import { ulid as ulid2 } from "ulid";
 
+// src/utils/date-parser.ts
+import * as chrono from "chrono-node";
+
+class DateParseError extends Error {
+  input;
+  suggestion;
+  constructor(input, suggestion) {
+    super(`Unable to parse date: "${input}"${suggestion ? `. Did you mean: ${suggestion}?` : ""}`);
+    this.input = input;
+    this.suggestion = suggestion;
+    this.name = "DateParseError";
+  }
+}
+var DURATION_REGEX = /^(\d+w)?\s*(\d+d)?\s*(\d+h)?\s*(\d+m)?$/i;
+function parseDate2(input, referenceDate) {
+  const trimmed = input.trim().toLowerCase();
+  if (!trimmed) {
+    throw new DateParseError(input);
+  }
+  if (/^-\d|in\s+-\d/i.test(trimmed)) {
+    throw new DateParseError(input, "Negative values not supported. Use positive durations.");
+  }
+  const durationMatch = trimmed.match(DURATION_REGEX);
+  if (durationMatch && (durationMatch[1] || durationMatch[2] || durationMatch[3] || durationMatch[4])) {
+    const weeks = parseInt(durationMatch[1] || "0", 10);
+    const days = parseInt(durationMatch[2] || "0", 10);
+    const hours = parseInt(durationMatch[3] || "0", 10);
+    const minutes = parseInt(durationMatch[4] || "0", 10);
+    const ref2 = referenceDate ?? new Date;
+    const result = new Date(ref2);
+    result.setDate(result.getDate() + weeks * 7 + days);
+    result.setHours(result.getHours() + hours);
+    result.setMinutes(result.getMinutes() + minutes);
+    return { date: result, hasTime: hours > 0 || minutes > 0 };
+  }
+  const ref = referenceDate ?? new Date;
+  const parsed = chrono.parseDate(input, ref, { forwardDate: true });
+  if (!parsed) {
+    const suggestions = {
+      tmrw: "tomorrow",
+      tom: "tomorrow",
+      tomorow: "tomorrow",
+      nxt: "next",
+      wk: "week"
+    };
+    const words = trimmed.split(/\s+/);
+    for (const word of words) {
+      if (suggestions[word]) {
+        throw new DateParseError(input, input.replace(word, suggestions[word]));
+      }
+    }
+    throw new DateParseError(input);
+  }
+  const hasTime = /\d{1,2}:\d{2}|(\d{1,2})\s*(am|pm)/i.test(input) || /at\s+\d/i.test(input);
+  return { date: parsed, hasTime };
+}
+function parseDateOrNull(input, referenceDate) {
+  if (!input?.trim())
+    return null;
+  try {
+    return parseDate2(input, referenceDate).date;
+  } catch {
+    return null;
+  }
+}
+
 // src/utils/similarity.ts
 function tokenize(text2) {
   const words = text2.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((word) => word.length > 0);
@@ -855,9 +1978,11 @@ class TaskService {
     threshold: 0.5,
     warnThreshold: 0.5
   };
+  depService;
   constructor(db, boardService) {
     this.db = db;
     this.boardService = boardService;
+    this.depService = new DependencyService(this.getTask.bind(this));
   }
   async getTaskOrThrow(id) {
     const task = await this.getTask(id);
@@ -870,61 +1995,80 @@ class TaskService {
     const title = validateTitle(input.title);
     const createdBy = input.createdBy ? validateAgentName(input.createdBy) : input.agent ? validateAgentName(input.agent) : "user";
     const columnId = input.columnId ? validateColumnId(input.columnId) : "todo";
+    const dueDate = parseDateOrNull(input.dueDate);
     const column = await this.boardService.getColumn(columnId);
     if (!column) {
       throw new KabanError(`Column '${columnId}' does not exist`, ExitCode.VALIDATION);
     }
+    const board = await this.boardService.getBoard();
+    if (!board) {
+      throw new KabanError("No board found", ExitCode.NOT_FOUND);
+    }
     const now = new Date;
     const id = ulid2();
-    const maxPositionResult = await this.db.select({ max: sql`COALESCE(MAX(position), -1)` }).from(tasks).where(eq2(tasks.columnId, columnId));
+    const maxPositionResult = await this.db.select({ max: sql2`COALESCE(MAX(position), -1)` }).from(tasks).where(eq4(tasks.columnId, columnId));
     const position = (maxPositionResult[0]?.max ?? -1) + 1;
-    await this.db.insert(tasks).values({
-      id,
-      title,
-      description: input.description ?? null,
-      columnId,
-      position,
-      createdBy,
-      assignedTo: null,
-      parentId: null,
-      dependsOn: input.dependsOn ?? [],
-      files: input.files ?? [],
-      labels: input.labels ?? [],
-      blockedReason: null,
-      version: 1,
-      createdAt: now,
-      updatedAt: now,
-      startedAt: null,
-      completedAt: null,
-      archived: false,
-      archivedAt: null
-    });
+    await this.db.run(sql2`
+      UPDATE boards 
+      SET max_board_task_id = max_board_task_id + 1 
+      WHERE id = ${board.id}
+    `);
+    await this.db.run(sql2`
+      INSERT INTO tasks (
+        id, board_task_id, title, description, column_id, position,
+        created_by, assigned_to, parent_id, depends_on, files, labels,
+        blocked_reason, version, created_at, updated_at, started_at,
+        completed_at, due_date, archived, archived_at
+      ) VALUES (
+        ${id},
+        (SELECT max_board_task_id FROM boards WHERE id = ${board.id}),
+        ${title},
+        ${input.description ?? null},
+        ${columnId},
+        ${position},
+        ${createdBy},
+        ${null},
+        ${null},
+        ${JSON.stringify(input.dependsOn ?? [])},
+        ${JSON.stringify(input.files ?? [])},
+        ${JSON.stringify(input.labels ?? [])},
+        ${null},
+        ${1},
+        ${Math.floor(now.getTime() / 1000)},
+        ${Math.floor(now.getTime() / 1000)},
+        ${null},
+        ${null},
+        ${dueDate ? Math.floor(dueDate.getTime() / 1000) : null},
+        ${0},
+        ${null}
+      )
+    `);
     return this.getTaskOrThrow(id);
   }
   async getTask(id) {
-    const rows = await this.db.select().from(tasks).where(eq2(tasks.id, id));
+    const rows = await this.db.select().from(tasks).where(eq4(tasks.id, id));
     return rows[0] ?? null;
   }
   async listTasks(filter) {
     const conditions = [];
     if (!filter?.includeArchived) {
-      conditions.push(eq2(tasks.archived, false));
+      conditions.push(eq4(tasks.archived, false));
     }
     if (filter?.columnId) {
-      conditions.push(eq2(tasks.columnId, filter.columnId));
+      conditions.push(eq4(tasks.columnId, filter.columnId));
     }
     const creatorFilter = filter?.createdBy ?? filter?.agent;
     if (creatorFilter) {
-      conditions.push(eq2(tasks.createdBy, creatorFilter));
+      conditions.push(eq4(tasks.createdBy, creatorFilter));
     }
     if (filter?.assignee) {
-      conditions.push(eq2(tasks.assignedTo, filter.assignee));
+      conditions.push(eq4(tasks.assignedTo, filter.assignee));
     }
     if (filter?.blocked === true) {
-      conditions.push(sql`${tasks.blockedReason} IS NOT NULL`);
+      conditions.push(sql2`${tasks.blockedReason} IS NOT NULL`);
     }
     if (conditions.length > 0) {
-      return this.db.select().from(tasks).where(and(...conditions)).orderBy(tasks.columnId, tasks.position);
+      return this.db.select().from(tasks).where(and3(...conditions)).orderBy(tasks.columnId, tasks.position);
     }
     return this.db.select().from(tasks).orderBy(tasks.columnId, tasks.position);
   }
@@ -933,7 +2077,7 @@ class TaskService {
     if (!task) {
       throw new KabanError(`Task '${id}' not found`, ExitCode.NOT_FOUND);
     }
-    await this.db.delete(tasks).where(eq2(tasks.id, id));
+    await this.db.delete(tasks).where(eq4(tasks.id, id));
   }
   async moveTask(id, columnId, options) {
     const task = await this.getTask(id);
@@ -959,7 +2103,7 @@ class TaskService {
     }
     const now = new Date;
     const isTerminal = column.isTerminal;
-    const maxPositionResult = await this.db.select({ max: sql`COALESCE(MAX(position), -1)` }).from(tasks).where(eq2(tasks.columnId, columnId));
+    const maxPositionResult = await this.db.select({ max: sql2`COALESCE(MAX(position), -1)` }).from(tasks).where(eq4(tasks.columnId, columnId));
     const newPosition = (maxPositionResult[0]?.max ?? -1) + 1;
     await this.db.update(tasks).set({
       columnId,
@@ -967,11 +2111,12 @@ class TaskService {
       version: task.version + 1,
       updatedAt: now,
       completedAt: isTerminal ? now : task.completedAt,
-      startedAt: columnId === "in_progress" && !task.startedAt ? now : task.startedAt
-    }).where(eq2(tasks.id, id));
+      startedAt: columnId === "in_progress" && !task.startedAt ? now : task.startedAt,
+      updatedBy: options?.actor ?? null
+    }).where(eq4(tasks.id, id));
     return this.getTaskOrThrow(id);
   }
-  async updateTask(id, input, expectedVersion) {
+  async updateTask(id, input, expectedVersion, actor) {
     const task = await this.getTask(id);
     if (!task) {
       throw new KabanError(`Task '${id}' not found`, ExitCode.NOT_FOUND);
@@ -981,7 +2126,8 @@ class TaskService {
     }
     const updates = {
       version: task.version + 1,
-      updatedAt: new Date
+      updatedAt: new Date,
+      updatedBy: actor ?? null
     };
     if (input.title !== undefined) {
       updates.title = validateTitle(input.title);
@@ -998,11 +2144,14 @@ class TaskService {
     if (input.labels !== undefined) {
       updates.labels = input.labels;
     }
-    await this.db.update(tasks).set(updates).where(expectedVersion !== undefined ? and(eq2(tasks.id, id), eq2(tasks.version, expectedVersion)) : eq2(tasks.id, id));
+    if (input.dueDate !== undefined) {
+      updates.dueDate = input.dueDate ? parseDateOrNull(input.dueDate) : null;
+    }
+    await this.db.update(tasks).set(updates).where(expectedVersion !== undefined ? and3(eq4(tasks.id, id), eq4(tasks.version, expectedVersion)) : eq4(tasks.id, id));
     return this.getTaskOrThrow(id);
   }
   async getTaskCountInColumn(columnId) {
-    const result = await this.db.select({ count: sql`COUNT(*)` }).from(tasks).where(eq2(tasks.columnId, columnId));
+    const result = await this.db.select({ count: sql2`COUNT(*)` }).from(tasks).where(eq4(tasks.columnId, columnId));
     return result[0]?.count ?? 0;
   }
   async archiveTasks(criteria) {
@@ -1010,9 +2159,9 @@ class TaskService {
     if (!hasCriteria) {
       throw new KabanError("At least one criteria must be provided", ExitCode.VALIDATION);
     }
-    const conditions = [eq2(tasks.archived, false)];
+    const conditions = [eq4(tasks.archived, false)];
     if (criteria.status) {
-      conditions.push(eq2(tasks.columnId, criteria.status));
+      conditions.push(eq4(tasks.columnId, criteria.status));
     }
     if (criteria.olderThan) {
       conditions.push(lt(tasks.createdAt, criteria.olderThan));
@@ -1020,7 +2169,7 @@ class TaskService {
     if (criteria.taskIds?.length) {
       conditions.push(inArray(tasks.id, criteria.taskIds));
     }
-    const matchingTasks = await this.db.select({ id: tasks.id }).from(tasks).where(and(...conditions));
+    const matchingTasks = await this.db.select({ id: tasks.id }).from(tasks).where(and3(...conditions));
     if (matchingTasks.length === 0) {
       return { archivedCount: 0, taskIds: [] };
     }
@@ -1059,16 +2208,16 @@ class TaskService {
       columnId,
       version: task.version + 1,
       updatedAt: now
-    }).where(eq2(tasks.id, taskId));
+    }).where(eq4(tasks.id, taskId));
     return this.getTaskOrThrow(taskId);
   }
   async searchArchive(query, options) {
     const limit = options?.limit ?? 50;
     const offset = options?.offset ?? 0;
     if (!query.trim()) {
-      const countResult = await this.db.select({ count: sql`COUNT(*)` }).from(tasks).where(eq2(tasks.archived, true));
+      const countResult = await this.db.select({ count: sql2`COUNT(*)` }).from(tasks).where(eq4(tasks.archived, true));
       const total2 = countResult[0]?.count ?? 0;
-      const archivedTasks = await this.db.select().from(tasks).where(eq2(tasks.archived, true)).orderBy(tasks.archivedAt).limit(limit).offset(offset);
+      const archivedTasks = await this.db.select().from(tasks).where(eq4(tasks.archived, true)).orderBy(tasks.archivedAt).limit(limit).offset(offset);
       return { tasks: archivedTasks, total: total2 };
     }
     const ftsQuery = query.trim().split(/\s+/).map((term) => `"${term}"`).join(" ");
@@ -1086,6 +2235,7 @@ class TaskService {
          LIMIT ? OFFSET ?`).all(ftsQuery, limit, offset);
     const searchTasks = rows.map((row) => ({
       id: row.id,
+      boardTaskId: row.board_task_id,
       title: row.title,
       description: row.description,
       columnId: row.column_id,
@@ -1102,17 +2252,19 @@ class TaskService {
       updatedAt: new Date(row.updated_at),
       startedAt: row.started_at ? new Date(row.started_at) : null,
       completedAt: row.completed_at ? new Date(row.completed_at) : null,
+      dueDate: row.due_date ? new Date(row.due_date * 1000) : null,
       archived: Boolean(row.archived),
-      archivedAt: row.archived_at ? new Date(row.archived_at) : null
+      archivedAt: row.archived_at ? new Date(row.archived_at) : null,
+      updatedBy: row.updated_by
     }));
     return { tasks: searchTasks, total };
   }
   async purgeArchive(criteria) {
-    const conditions = [eq2(tasks.archived, true)];
+    const conditions = [eq4(tasks.archived, true)];
     if (criteria?.olderThan) {
       conditions.push(lt(tasks.archivedAt, criteria.olderThan));
     }
-    const matchingTasks = await this.db.select({ id: tasks.id }).from(tasks).where(and(...conditions));
+    const matchingTasks = await this.db.select({ id: tasks.id }).from(tasks).where(and3(...conditions));
     if (matchingTasks.length === 0) {
       return { deletedCount: 0 };
     }
@@ -1125,7 +2277,7 @@ class TaskService {
     if (allTasks.length === 0) {
       return { deletedCount: 0 };
     }
-    await this.db.delete(tasks).where(sql`1=1`);
+    await this.db.delete(tasks);
     return { deletedCount: allTasks.length };
   }
   async addDependency(taskId, dependsOnId) {
@@ -1137,13 +2289,18 @@ class TaskService {
     if (task.dependsOn.includes(dependsOnId)) {
       return task;
     }
+    const cycleCheck = await this.depService.wouldCreateCycle(taskId, dependsOnId);
+    if (cycleCheck.hasCycle && cycleCheck.cyclePath) {
+      const cyclePath = this.depService.formatCyclePath(cycleCheck.cyclePath);
+      throw new KabanError(`Cannot add dependency - would create cycle: ${cyclePath}`, ExitCode.VALIDATION);
+    }
     const updatedDependsOn = [...task.dependsOn, dependsOnId];
     const now = new Date;
     await this.db.update(tasks).set({
       dependsOn: updatedDependsOn,
       version: task.version + 1,
       updatedAt: now
-    }).where(eq2(tasks.id, taskId));
+    }).where(eq4(tasks.id, taskId));
     return this.getTaskOrThrow(taskId);
   }
   async removeDependency(taskId, dependsOnId) {
@@ -1157,7 +2314,7 @@ class TaskService {
       dependsOn: updatedDependsOn,
       version: task.version + 1,
       updatedAt: now
-    }).where(eq2(tasks.id, taskId));
+    }).where(eq4(tasks.id, taskId));
     return this.getTaskOrThrow(taskId);
   }
   async validateDependencies(taskId) {
@@ -1213,7 +2370,7 @@ class TaskService {
     };
   }
   async getArchiveStats() {
-    const archived = await this.db.select().from(tasks).where(eq2(tasks.archived, true));
+    const archived = await this.db.select().from(tasks).where(eq4(tasks.archived, true));
     const byColumn = {};
     let oldestArchivedAt = null;
     for (const task of archived) {
@@ -1228,6 +2385,37 @@ class TaskService {
       oldestArchivedAt
     };
   }
+  async resolveTask(idOrShortId, boardId) {
+    const cleanId = idOrShortId.replace(/^#/, "").trim();
+    if (/^\d+$/.test(cleanId)) {
+      const shortId = parseInt(cleanId, 10);
+      const board = boardId ? { id: boardId } : await this.boardService.getBoard();
+      if (board) {
+        return this.getTaskByBoardTaskId(board.id, shortId);
+      }
+      return null;
+    }
+    if (/^[0-9A-Z]{26}$/i.test(cleanId)) {
+      return this.getTask(cleanId);
+    }
+    if (cleanId.length >= 4 && /^[0-9A-Z]+$/i.test(cleanId)) {
+      return this.getTaskByIdPrefix(cleanId);
+    }
+    return null;
+  }
+  async getTaskByBoardTaskId(boardId, boardTaskId) {
+    const result = await this.db.select().from(tasks).innerJoin(columns, eq4(tasks.columnId, columns.id)).where(and3(eq4(columns.boardId, boardId), eq4(tasks.boardTaskId, boardTaskId))).limit(1);
+    return result[0]?.tasks ?? null;
+  }
+  async getTaskByIdPrefix(prefix) {
+    const result = await this.db.select().from(tasks).where(sql2`${tasks.id} LIKE ${prefix.toUpperCase() + "%"}`).limit(2);
+    if (result.length === 0)
+      return null;
+    if (result.length > 1) {
+      throw new KabanError(`Ambiguous task ID prefix: ${prefix}. Multiple matches found.`, ExitCode.VALIDATION);
+    }
+    return result[0];
+  }
 }
 
 // src/index.ts
@@ -1240,26 +2428,38 @@ export {
   undoLog,
   tokenize,
   tasks,
+  taskLinks,
   runMigrations,
+  priorityScorer,
+  linkTypes,
   jsonSchemas,
   jaccardSimilarity,
   isValidUlid,
   initializeSchema,
   getJsonSchema,
+  fifoScorer,
+  dueDateScorer,
+  createDefaultScoringService,
   createDb,
+  createBlockingScorer,
   columns,
   boards,
+  audits,
   UpdateTaskInputSchema,
   UlidSchema,
   TitleSchema,
   TaskService,
   TaskSchema,
   TaskResponseSchema,
+  ScoringService,
   MoveTaskInputSchema,
+  MarkdownService,
   ListTasksFilterSchema,
+  LinkService,
   KabanError,
   GetTaskInputSchema,
   ExitCode,
+  DependencyService,
   DeleteTaskInputSchema,
   DEFAULT_CONFIG,
   ConfigSchema,
@@ -1269,6 +2469,7 @@ export {
   BoardStatusSchema,
   BoardService,
   BoardSchema,
+  AuditService,
   ApiResponseSchema,
   AgentNameSchema,
   AddTaskInputSchema