@tomkapa/tayto 0.1.0

package/dist/index.js

@@ -0,0 +1,1962 @@
+#!/usr/bin/env node
+import {
+  DependencyType,
+  RANK_GAP,
+  TERMINAL_STATUSES,
+  TaskStatus,
+  TaskType,
+  UIDependencyType,
+  isTerminalStatus,
+  logger
+} from "./chunk-6NQOFUIQ.js";
+
+// src/config/index.ts
+import { mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true });
+}
+function loadConfig() {
+  const dataDir = process.env["TASK_DATA_DIR"] ?? join(homedir(), ".task");
+  ensureDir(dataDir);
+  const logDir = process.env["TASK_LOG_DIR"] ?? join(dataDir, "logs");
+  ensureDir(logDir);
+  return {
+    dbPath: process.env["TASK_DB_PATH"] ?? join(dataDir, "data.db"),
+    logDir,
+    logLevel: process.env["TASK_LOG_LEVEL"] ?? "info",
+    otelEndpoint: process.env["OTEL_EXPORTER_OTLP_ENDPOINT"]
+  };
+}
+
+// src/db/connection.ts
+import Database from "better-sqlite3";
+function createDatabase(dbPath) {
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  return db;
+}
+
+// src/db/migrator.ts
+import { readdirSync, readFileSync } from "fs";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+var migrationsDir = join2(dirname(fileURLToPath(import.meta.url)), "migrations");
+function loadMigrations() {
+  const files = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")).sort();
+  return files.map((name) => ({
+    name,
+    sql: readFileSync(join2(migrationsDir, name), "utf-8")
+  }));
+}
+function runMigrations(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _migrations (
+      name       TEXT PRIMARY KEY,
+      applied_at TEXT NOT NULL
+    );
+  `);
+  const applied = new Set(
+    db.prepare("SELECT name FROM _migrations").all().map(
+      (r) => r.name
+    )
+  );
+  const migrations = loadMigrations();
+  for (const migration of migrations) {
+    if (applied.has(migration.name)) continue;
+    logger.info(`Applying migration: ${migration.name}`);
+    const migrate = db.transaction(() => {
+      db.exec(migration.sql);
+      db.prepare("INSERT INTO _migrations (name, applied_at) VALUES (?, ?)").run(
+        migration.name,
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+    });
+    migrate();
+    logger.info(`Migration applied: ${migration.name}`);
+  }
+}
+
+// src/logging/telemetry.ts
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { BatchSpanProcessor, ConsoleSpanExporter } from "@opentelemetry/sdk-trace-base";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+var sdk;
+function initTelemetry(config) {
+  const spanProcessor = config.otelEndpoint ? new BatchSpanProcessor(new OTLPTraceExporter({ url: config.otelEndpoint })) : config.logLevel === "debug" ? new BatchSpanProcessor(new ConsoleSpanExporter()) : void 0;
+  sdk = new NodeSDK({
+    serviceName: "task",
+    spanProcessors: spanProcessor ? [spanProcessor] : []
+  });
+  sdk.start();
+}
+async function shutdownTelemetry() {
+  if (sdk) {
+    await sdk.shutdown();
+  }
+}
+
+// src/types/common.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+
+// src/errors/app-error.ts
+var AppError = class extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "AppError";
+  }
+  code;
+  cause;
+};
+
+// src/repository/project.repository.ts
+import { ulid } from "ulid";
+
+// src/repository/shared.ts
+var NOT_DELETED = "deleted_at IS NULL";
+function rowToTask(row) {
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    parentId: row.parent_id,
+    name: row.name,
+    description: row.description,
+    type: row.type,
+    status: row.status,
+    rank: row.rank,
+    technicalNotes: row.technical_notes,
+    additionalRequirements: row.additional_requirements,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+
+// src/repository/project.repository.ts
+function rowToProject(row) {
+  return {
+    id: row.id,
+    key: row.key,
+    name: row.name,
+    description: row.description,
+    isDefault: row.is_default === 1,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+var SqliteProjectRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  insert(input) {
+    return logger.startSpan("ProjectRepository.insert", () => {
+      try {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const id = ulid();
+        if (input.isDefault) {
+          this.db.prepare("UPDATE projects SET is_default = 0 WHERE is_default = 1").run();
+        }
+        this.db.prepare(
+          `INSERT INTO projects (id, key, name, description, is_default, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+          id,
+          input.key,
+          input.name,
+          input.description ?? "",
+          input.isDefault ? 1 : 0,
+          now,
+          now
+        );
+        const row = this.db.prepare("SELECT * FROM projects WHERE id = ?").get(id);
+        if (!row) {
+          return err(new AppError("DB_ERROR", "Failed to retrieve inserted project"));
+        }
+        return ok(rowToProject(row));
+      } catch (e) {
+        if (e instanceof Error && e.message.includes("UNIQUE constraint")) {
+          return err(new AppError("DUPLICATE", `Project name already exists: ${input.name}`, e));
+        }
+        return err(new AppError("DB_ERROR", "Failed to insert project", e));
+      }
+    });
+  }
+  findById(id) {
+    try {
+      const row = this.db.prepare(`SELECT * FROM projects WHERE id = ? AND ${NOT_DELETED}`).get(id);
+      return ok(row ? rowToProject(row) : null);
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to find project by id", e));
+    }
+  }
+  findByKey(key) {
+    try {
+      const row = this.db.prepare(`SELECT * FROM projects WHERE key = ? AND ${NOT_DELETED}`).get(key);
+      return ok(row ? rowToProject(row) : null);
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to find project by key", e));
+    }
+  }
+  findByName(name) {
+    try {
+      const row = this.db.prepare(`SELECT * FROM projects WHERE name = ? AND ${NOT_DELETED}`).get(name);
+      return ok(row ? rowToProject(row) : null);
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to find project by name", e));
+    }
+  }
+  findDefault() {
+    try {
+      const row = this.db.prepare(`SELECT * FROM projects WHERE is_default = 1 AND ${NOT_DELETED}`).get();
+      return ok(row ? rowToProject(row) : null);
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to find default project", e));
+    }
+  }
+  findAll() {
+    try {
+      const rows = this.db.prepare(`SELECT * FROM projects WHERE ${NOT_DELETED} ORDER BY created_at DESC`).all();
+      return ok(rows.map(rowToProject));
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to list projects", e));
+    }
+  }
+  update(id, input) {
+    return logger.startSpan("ProjectRepository.update", () => {
+      try {
+        const existing = this.db.prepare(`SELECT * FROM projects WHERE id = ? AND ${NOT_DELETED}`).get(id);
+        if (!existing) {
+          return err(new AppError("NOT_FOUND", `Project not found: ${id}`));
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        if (input.isDefault) {
+          this.db.prepare("UPDATE projects SET is_default = 0 WHERE is_default = 1").run();
+        }
+        this.db.prepare(
+          `UPDATE projects SET
+               name = ?, description = ?, is_default = ?, updated_at = ?
+             WHERE id = ?`
+        ).run(
+          input.name ?? existing.name,
+          input.description ?? existing.description,
+          input.isDefault !== void 0 ? input.isDefault ? 1 : 0 : existing.is_default,
+          now,
+          id
+        );
+        const row = this.db.prepare("SELECT * FROM projects WHERE id = ?").get(id);
+        if (!row) {
+          return err(new AppError("DB_ERROR", "Failed to retrieve updated project"));
+        }
+        return ok(rowToProject(row));
+      } catch (e) {
+        if (e instanceof Error && e.message.includes("UNIQUE constraint")) {
+          return err(new AppError("DUPLICATE", `Project name already exists`, e));
+        }
+        return err(new AppError("DB_ERROR", "Failed to update project", e));
+      }
+    });
+  }
+  delete(id) {
+    return logger.startSpan("ProjectRepository.delete", () => {
+      try {
+        const existing = this.db.prepare(`SELECT * FROM projects WHERE id = ? AND ${NOT_DELETED}`).get(id);
+        if (!existing) {
+          return err(new AppError("NOT_FOUND", `Project not found: ${id}`));
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        this.db.prepare("UPDATE projects SET deleted_at = ?, updated_at = ? WHERE id = ?").run(now, now, id);
+        this.db.prepare(
+          "UPDATE tasks SET deleted_at = ?, updated_at = ? WHERE project_id = ? AND deleted_at IS NULL"
+        ).run(now, now, id);
+        return ok(void 0);
+      } catch (e) {
+        return err(new AppError("DB_ERROR", "Failed to delete project", e));
+      }
+    });
+  }
+  incrementTaskCounter(id) {
+    return logger.startSpan("ProjectRepository.incrementTaskCounter", () => {
+      try {
+        this.db.prepare(
+          `UPDATE projects SET task_counter = task_counter + 1 WHERE id = ? AND ${NOT_DELETED}`
+        ).run(id);
+        const row = this.db.prepare(`SELECT task_counter FROM projects WHERE id = ? AND ${NOT_DELETED}`).get(id);
+        if (!row) {
+          return err(new AppError("NOT_FOUND", `Project not found: ${id}`));
+        }
+        return ok(row.task_counter);
+      } catch (e) {
+        return err(new AppError("DB_ERROR", "Failed to increment task counter", e));
+      }
+    });
+  }
+};
+
+// src/repository/task.repository.ts
+var TERMINAL_STATUS_ARRAY = [...TERMINAL_STATUSES];
+var TERMINAL_PLACEHOLDERS = TERMINAL_STATUS_ARRAY.map(() => "?").join(", ");
+var SqliteTaskRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  insert(id, input) {
+    return logger.startSpan("TaskRepository.insert", () => {
+      try {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const maxActiveResult = this.getMaxActiveRank(input.projectId);
+        if (!maxActiveResult.ok) return maxActiveResult;
+        const maxActiveRank = maxActiveResult.value;
+        const minTerminalResult = this.getMinTerminalRank(input.projectId);
+        if (!minTerminalResult.ok) return minTerminalResult;
+        const minTerminalRank = minTerminalResult.value;
+        let rank;
+        if (minTerminalRank !== null && minTerminalRank > maxActiveRank) {
+          rank = maxActiveRank > 0 ? (maxActiveRank + minTerminalRank) / 2 : minTerminalRank - RANK_GAP;
+        } else {
+          rank = maxActiveRank + RANK_GAP;
+        }
+        this.db.prepare(
+          `INSERT INTO tasks (id, project_id, parent_id, name, description, type, status, rank, technical_notes, additional_requirements, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+          id,
+          input.projectId,
+          input.parentId ?? null,
+          input.name,
+          input.description ?? "",
+          input.type,
+          input.status,
+          rank,
+          input.technicalNotes ?? "",
+          input.additionalRequirements ?? "",
+          now,
+          now
+        );
+        const row = this.db.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
+        if (!row) {
+          return err(new AppError("DB_ERROR", "Failed to retrieve inserted task"));
+        }
+        return ok(rowToTask(row));
+      } catch (e) {
+        return err(new AppError("DB_ERROR", "Failed to insert task", e));
+      }
+    });
+  }
+  findById(id) {
+    try {
+      const row = this.db.prepare(`SELECT * FROM tasks WHERE id = ? AND ${NOT_DELETED}`).get(id);
+      return ok(row ? rowToTask(row) : null);
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to find task by id", e));
+    }
+  }
+  findMany(filter) {
+    try {
+      const conditions = [NOT_DELETED];
+      const params = [];
+      if (filter.projectId) {
+        conditions.push("project_id = ?");
+        params.push(filter.projectId);
+      }
+      if (filter.status) {
+        conditions.push("status = ?");
+        params.push(filter.status);
+      }
+      if (filter.type) {
+        conditions.push("type = ?");
+        params.push(filter.type);
+      }
+      if (filter.parentId) {
+        conditions.push("parent_id = ?");
+        params.push(filter.parentId);
+      }
+      if (filter.search) {
+        const ftsQuery = filter.search.trim().split(/\s+/).map((term) => `"${term.replace(/"/g, '""')}"*`).join(" ");
+        conditions.push(`id IN (SELECT id FROM tasks_fts WHERE tasks_fts MATCH ?)`);
+        params.push(ftsQuery);
+      }
+      const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const sql = `SELECT * FROM tasks ${where} ORDER BY rank ASC`;
+      const rows = this.db.prepare(sql).all(...params);
+      return ok(rows.map(rowToTask));
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to list tasks", e));
+    }
+  }
+  update(id, input) {
+    return logger.startSpan("TaskRepository.update", () => {
+      try {
+        const existing = this.db.prepare(`SELECT * FROM tasks WHERE id = ? AND ${NOT_DELETED}`).get(id);
+        if (!existing) {
+          return err(new AppError("NOT_FOUND", `Task not found: ${id}`));
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        let technicalNotes = input.technicalNotes ?? existing.technical_notes;
+        if (input.appendNotes) {
+          technicalNotes = existing.technical_notes + (existing.technical_notes ? `
+
+---
+_${now}_
+
+` : "") + input.appendNotes;
+        }
+        let additionalRequirements = input.additionalRequirements ?? existing.additional_requirements;
+        if (input.appendRequirements) {
+          additionalRequirements = existing.additional_requirements + (existing.additional_requirements ? `
+
+---
+_${now}_
+
+` : "") + input.appendRequirements;
+        }
+        this.db.prepare(
+          `UPDATE tasks SET
+               name = ?, description = ?, type = ?, status = ?,
+               parent_id = ?, technical_notes = ?, additional_requirements = ?, updated_at = ?
+             WHERE id = ?`
+        ).run(
+          input.name ?? existing.name,
+          input.description ?? existing.description,
+          input.type ?? existing.type,
+          input.status ?? existing.status,
+          input.parentId !== void 0 ? input.parentId : existing.parent_id,
+          technicalNotes,
+          additionalRequirements,
+          now,
+          id
+        );
+        const row = this.db.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
+        if (!row) {
+          return err(new AppError("DB_ERROR", "Failed to retrieve updated task"));
+        }
+        return ok(rowToTask(row));
+      } catch (e) {
+        return err(new AppError("DB_ERROR", "Failed to update task", e));
+      }
+    });
+  }
+  delete(id) {
+    return logger.startSpan("TaskRepository.delete", () => {
+      try {
+        const existing = this.db.prepare(`SELECT * FROM tasks WHERE id = ? AND ${NOT_DELETED}`).get(id);
+        if (!existing) {
+          return err(new AppError("NOT_FOUND", `Task not found: ${id}`));
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        this.db.prepare("UPDATE tasks SET deleted_at = ?, updated_at = ? WHERE id = ?").run(now, now, id);
+        return ok(void 0);
+      } catch (e) {
+        return err(new AppError("DB_ERROR", "Failed to delete task", e));
+      }
+    });
+  }
+  rerank(taskId, newRank) {
+    return logger.startSpan("TaskRepository.rerank", () => {
+      try {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const existing = this.db.prepare(`SELECT * FROM tasks WHERE id = ? AND ${NOT_DELETED}`).get(taskId);
+        if (!existing) {
+          return err(new AppError("NOT_FOUND", `Task not found: ${taskId}`));
+        }
+        this.db.prepare("UPDATE tasks SET rank = ?, updated_at = ? WHERE id = ?").run(newRank, now, taskId);
+        const row = this.db.prepare("SELECT * FROM tasks WHERE id = ?").get(taskId);
+        if (!row) {
+          return err(new AppError("DB_ERROR", "Failed to retrieve reranked task"));
+        }
+        return ok(rowToTask(row));
+      } catch (e) {
+        return err(new AppError("DB_ERROR", "Failed to rerank task", e));
+      }
+    });
+  }
+  getMaxRank(projectId) {
+    try {
+      const row = this.db.prepare(`SELECT MAX(rank) as max_rank FROM tasks WHERE project_id = ? AND ${NOT_DELETED}`).get(projectId);
+      return ok(row?.max_rank ?? 0);
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to get max rank", e));
+    }
+  }
+  getMaxActiveRank(projectId) {
+    try {
+      const row = this.db.prepare(
+        `SELECT MAX(rank) as max_rank FROM tasks WHERE project_id = ? AND ${NOT_DELETED} AND status NOT IN (${TERMINAL_PLACEHOLDERS})`
+      ).get(projectId, ...TERMINAL_STATUS_ARRAY);
+      return ok(row?.max_rank ?? 0);
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to get max active rank", e));
+    }
+  }
+  getMinTerminalRank(projectId) {
+    try {
+      const row = this.db.prepare(
+        `SELECT MIN(rank) as min_rank FROM tasks WHERE project_id = ? AND ${NOT_DELETED} AND status IN (${TERMINAL_PLACEHOLDERS})`
+      ).get(projectId, ...TERMINAL_STATUS_ARRAY);
+      return ok(row?.min_rank ?? null);
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to get min terminal rank", e));
+    }
+  }
+  getRankedTasks(projectId, status) {
+    try {
+      let sql;
+      let params;
+      if (status) {
+        sql = `SELECT * FROM tasks WHERE project_id = ? AND ${NOT_DELETED} AND status = ? ORDER BY rank ASC`;
+        params = [projectId, status];
+      } else {
+        sql = `SELECT * FROM tasks WHERE project_id = ? AND ${NOT_DELETED} ORDER BY rank ASC`;
+        params = [projectId];
+      }
+      const rows = this.db.prepare(sql).all(...params);
+      return ok(rows.map(rowToTask));
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to get ranked tasks", e));
+    }
+  }
+  search(query, projectId) {
+    return logger.startSpan("TaskRepository.search", () => {
+      try {
+        const ftsQuery = query.trim().split(/\s+/).map((term) => `"${term.replace(/"/g, '""')}"*`).join(" ");
+        let sql;
+        let params;
+        if (projectId) {
+          sql = `SELECT t.*, bm25(tasks_fts) AS fts_rank
+                 FROM tasks_fts f
+                 JOIN tasks t ON t.id = f.id AND t.deleted_at IS NULL
+                 WHERE tasks_fts MATCH ? AND t.project_id = ?
+                 ORDER BY fts_rank ASC`;
+          params = [ftsQuery, projectId];
+        } else {
+          sql = `SELECT t.*, bm25(tasks_fts) AS fts_rank
+                 FROM tasks_fts f
+                 JOIN tasks t ON t.id = f.id AND t.deleted_at IS NULL
+                 WHERE tasks_fts MATCH ?
+                 ORDER BY fts_rank ASC`;
+          params = [ftsQuery];
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return ok(
+          rows.map((row) => ({
+            task: rowToTask(row),
+            rank: row.fts_rank
+          }))
+        );
+      } catch (e) {
+        return err(new AppError("DB_ERROR", "Full-text search failed", e));
+      }
+    });
+  }
+};
+
+// src/repository/dependency.repository.ts
+function rowToDependency(row) {
+  return {
+    taskId: row.task_id,
+    dependsOnId: row.depends_on_id,
+    type: row.type,
+    createdAt: row.created_at
+  };
+}
+var SqliteDependencyRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  insert(taskId, dependsOnId, type) {
+    return logger.startSpan("DependencyRepository.insert", () => {
+      try {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        this.db.prepare(
+          `INSERT INTO task_dependencies (task_id, depends_on_id, type, created_at)
+             VALUES (?, ?, ?, ?)`
+        ).run(taskId, dependsOnId, type, now);
+        const row = this.db.prepare("SELECT * FROM task_dependencies WHERE task_id = ? AND depends_on_id = ?").get(taskId, dependsOnId);
+        if (!row) {
+          return err(new AppError("DB_ERROR", "Failed to retrieve inserted dependency"));
+        }
+        return ok(rowToDependency(row));
+      } catch (e) {
+        if (e instanceof Error && e.message.includes("UNIQUE constraint")) {
+          return err(
+            new AppError("DUPLICATE", `Dependency already exists: ${taskId} -> ${dependsOnId}`, e)
+          );
+        }
+        if (e instanceof Error && e.message.includes("FOREIGN KEY constraint")) {
+          return err(new AppError("NOT_FOUND", "One or both tasks do not exist", e));
+        }
+        if (e instanceof Error && e.message.includes("CHECK constraint")) {
+          return err(new AppError("VALIDATION", "A task cannot depend on itself", e));
+        }
+        return err(new AppError("DB_ERROR", "Failed to insert dependency", e));
+      }
+    });
+  }
+  delete(taskId, dependsOnId) {
+    return logger.startSpan("DependencyRepository.delete", () => {
+      try {
+        const existing = this.db.prepare("SELECT * FROM task_dependencies WHERE task_id = ? AND depends_on_id = ?").get(taskId, dependsOnId);
+        if (!existing) {
+          return err(
+            new AppError("NOT_FOUND", `Dependency not found: ${taskId} -> ${dependsOnId}`)
+          );
+        }
+        this.db.prepare("DELETE FROM task_dependencies WHERE task_id = ? AND depends_on_id = ?").run(taskId, dependsOnId);
+        return ok(void 0);
+      } catch (e) {
+        return err(new AppError("DB_ERROR", "Failed to delete dependency", e));
+      }
+    });
+  }
+  findByTask(taskId) {
+    try {
+      const rows = this.db.prepare("SELECT * FROM task_dependencies WHERE task_id = ? ORDER BY created_at ASC").all(taskId);
+      return ok(rows.map(rowToDependency));
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to find dependencies for task", e));
+    }
+  }
+  findDependents(taskId) {
+    try {
+      const rows = this.db.prepare("SELECT * FROM task_dependencies WHERE depends_on_id = ? ORDER BY created_at ASC").all(taskId);
+      return ok(rows.map(rowToDependency));
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to find dependents for task", e));
+    }
+  }
+  getBlockers(taskId) {
+    try {
+      const rows = this.db.prepare(
+        `SELECT t.* FROM tasks t
+           JOIN task_dependencies td ON t.id = td.depends_on_id
+           WHERE td.task_id = ? AND td.type = 'blocks' AND t.deleted_at IS NULL
+           ORDER BY t.rank ASC`
+      ).all(taskId);
+      return ok(rows.map(rowToTask));
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to get blockers", e));
+    }
+  }
+  getDependents(taskId) {
+    try {
+      const rows = this.db.prepare(
+        `SELECT t.* FROM tasks t
+           JOIN task_dependencies td ON t.id = td.task_id
+           WHERE td.depends_on_id = ? AND td.type = 'blocks' AND t.deleted_at IS NULL
+           ORDER BY t.rank ASC`
+      ).all(taskId);
+      return ok(rows.map(rowToTask));
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to get dependents", e));
+    }
+  }
+  getRelated(taskId) {
+    try {
+      const rows = this.db.prepare(
+        `SELECT DISTINCT t.* FROM tasks t
+           JOIN task_dependencies td ON (
+             (td.task_id = ? AND td.depends_on_id = t.id) OR
+             (td.depends_on_id = ? AND td.task_id = t.id)
+           )
+           WHERE td.type = 'relates-to' AND t.deleted_at IS NULL
+           ORDER BY t.rank ASC`
+      ).all(taskId, taskId);
+      return ok(rows.map(rowToTask));
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to get related tasks", e));
+    }
+  }
+  getDuplicates(taskId) {
+    try {
+      const rows = this.db.prepare(
+        `SELECT DISTINCT t.* FROM tasks t
+           JOIN task_dependencies td ON (
+             (td.task_id = ? AND td.depends_on_id = t.id) OR
+             (td.depends_on_id = ? AND td.task_id = t.id)
+           )
+           WHERE td.type = 'duplicates' AND t.deleted_at IS NULL
+           ORDER BY t.rank ASC`
+      ).all(taskId, taskId);
+      return ok(rows.map(rowToTask));
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to get duplicate tasks", e));
+    }
+  }
+  getTransitiveClosure(taskId) {
+    try {
+      const rows = this.db.prepare(
+        `WITH RECURSIVE transitive_deps(id) AS (
+             SELECT depends_on_id FROM task_dependencies WHERE task_id = ?
+             UNION
+             SELECT td.depends_on_id FROM task_dependencies td
+             JOIN transitive_deps d ON td.task_id = d.id
+           )
+           SELECT t.* FROM tasks t
+           WHERE t.id IN (SELECT id FROM transitive_deps) AND t.deleted_at IS NULL
+           ORDER BY t.rank ASC`
+      ).all(taskId);
+      return ok(rows.map(rowToTask));
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to get transitive closure", e));
+    }
+  }
+  wouldCreateCycle(taskId, dependsOnId) {
+    try {
+      const row = this.db.prepare(
+        `WITH RECURSIVE reachable(id) AS (
+             SELECT depends_on_id FROM task_dependencies WHERE task_id = ?
+             UNION
+             SELECT td.depends_on_id FROM task_dependencies td
+             JOIN reachable r ON td.task_id = r.id
+           )
+           SELECT 1 AS found FROM reachable WHERE id = ? LIMIT 1`
+      ).get(dependsOnId, taskId);
+      return ok(row !== void 0);
+    } catch (e) {
+      return err(new AppError("DB_ERROR", "Failed to check for cycle", e));
+    }
+  }
+};
+
+// src/types/project.ts
+import { z } from "zod/v4";
+var CreateProjectSchema = z.object({
+  name: z.string().min(1, "Project name is required").max(255),
+  key: z.string().min(2, "Project key must be at least 2 characters").max(7, "Project key must be at most 7 characters").regex(/^[A-Za-z0-9]+$/, "Project key must contain only letters and digits").transform((v) => v.toUpperCase()).optional(),
+  description: z.string().max(5e3).optional(),
+  isDefault: z.boolean().optional()
+});
+var UpdateProjectSchema = z.object({
+  name: z.string().min(1).max(255).optional(),
+  description: z.string().max(5e3).optional(),
+  isDefault: z.boolean().optional()
+});
+
+// src/service/project.service.ts
+var ProjectServiceImpl = class {
+  constructor(repo) {
+    this.repo = repo;
+  }
+  repo;
+  createProject(input) {
+    return logger.startSpan("ProjectService.createProject", () => {
+      const parsed = CreateProjectSchema.safeParse(input);
+      if (!parsed.success) {
+        return err(new AppError("VALIDATION", parsed.error.message));
+      }
+      const key = parsed.data.key ?? this.generateKey(parsed.data.name);
+      const keyError = this.validateKey(key);
+      if (keyError) {
+        return err(new AppError("VALIDATION", keyError));
+      }
+      const existingResult = this.repo.findByKey(key);
+      if (!existingResult.ok) return existingResult;
+      if (existingResult.value) {
+        return err(new AppError("DUPLICATE", `Project key already exists: ${key}`));
+      }
+      return this.repo.insert({ ...parsed.data, key });
+    });
+  }
+  generateKey(name) {
+    return name.replace(/[^A-Za-z0-9]/g, "").slice(0, 3).toUpperCase();
+  }
+  validateKey(key) {
+    if (key.length < 2 || key.length > 7) {
+      return `Project key must be 2-7 characters, got ${key.length}. Provide a --key explicitly.`;
+    }
+    if (!/^[A-Z0-9]+$/.test(key)) {
+      return "Project key must contain only uppercase letters and digits.";
+    }
+    return null;
+  }
+  listProjects() {
+    return this.repo.findAll();
+  }
+  getProject(id) {
+    return logger.startSpan("ProjectService.getProject", () => {
+      const result = this.repo.findById(id);
+      if (!result.ok) return result;
+      if (!result.value) {
+        return err(new AppError("NOT_FOUND", `Project not found: ${id}`));
+      }
+      return ok(result.value);
+    });
+  }
+  updateProject(id, input) {
+    return logger.startSpan("ProjectService.updateProject", () => {
+      const parsed = UpdateProjectSchema.safeParse(input);
+      if (!parsed.success) {
+        return err(new AppError("VALIDATION", parsed.error.message));
+      }
+      return this.repo.update(id, parsed.data);
+    });
+  }
+  deleteProject(id) {
+    return this.repo.delete(id);
+  }
+  resolveProject(idOrName) {
+    return logger.startSpan("ProjectService.resolveProject", () => {
+      if (idOrName) {
+        const byId = this.repo.findById(idOrName);
+        if (!byId.ok) return byId;
+        if (byId.value) return ok(byId.value);
+        const byKey = this.repo.findByKey(idOrName.toUpperCase());
+        if (!byKey.ok) return byKey;
+        if (byKey.value) return ok(byKey.value);
+        const byName = this.repo.findByName(idOrName);
+        if (!byName.ok) return byName;
+        if (byName.value) return ok(byName.value);
+        return err(new AppError("NOT_FOUND", `Project not found: ${idOrName}`));
+      }
+      const defaultProject = this.repo.findDefault();
+      if (!defaultProject.ok) return defaultProject;
+      if (defaultProject.value) return ok(defaultProject.value);
+      return err(
+        new AppError(
+          "NOT_FOUND",
+          "No project specified and no default project set. Create a project first."
+        )
+      );
+    });
+  }
+  nextTaskId(project) {
+    return logger.startSpan("ProjectService.nextTaskId", () => {
+      const counterResult = this.repo.incrementTaskCounter(project.id);
+      if (!counterResult.ok) return counterResult;
+      return ok(`${project.key}-${counterResult.value}`);
+    });
+  }
+};
+
+// src/types/task.ts
+import { z as z2 } from "zod/v4";
+var taskStatusValues = Object.values(TaskStatus);
+var taskTypeValues = Object.values(TaskType);
+var uiDepTypeValues = Object.values(UIDependencyType);
+var DependencyEntrySchema = z2.object({
+  id: z2.string().min(1),
+  type: z2.enum(uiDepTypeValues).default(DependencyType.Blocks)
+});
+var CreateTaskSchema = z2.object({
+  name: z2.string().min(1, "Task name is required").max(500),
+  description: z2.string().max(1e4).optional(),
+  type: z2.enum(taskTypeValues).default(TaskType.Story),
+  status: z2.enum(taskStatusValues).default(TaskStatus.Backlog),
+  projectId: z2.string().optional(),
+  parentId: z2.string().optional(),
+  technicalNotes: z2.string().max(5e4).optional(),
+  additionalRequirements: z2.string().max(5e4).optional(),
+  dependsOn: z2.array(DependencyEntrySchema).optional()
+});
+var UpdateTaskSchema = z2.object({
+  name: z2.string().min(1).max(500).optional(),
+  description: z2.string().max(1e4).optional(),
+  type: z2.enum(taskTypeValues).optional(),
+  status: z2.enum(taskStatusValues).optional(),
+  parentId: z2.string().nullable().optional(),
+  technicalNotes: z2.string().max(5e4).optional(),
+  additionalRequirements: z2.string().max(5e4).optional(),
+  appendNotes: z2.string().max(5e4).optional(),
+  appendRequirements: z2.string().max(5e4).optional()
+});
+var TaskFilterSchema = z2.object({
+  projectId: z2.string().optional(),
+  status: z2.enum(taskStatusValues).optional(),
+  type: z2.enum(taskTypeValues).optional(),
+  parentId: z2.string().optional(),
+  search: z2.string().optional()
+});
+var RerankTaskSchema = z2.object({
+  taskId: z2.string().min(1, "Task id is required"),
+  afterId: z2.string().optional(),
+  beforeId: z2.string().optional(),
+  position: z2.number().int().min(1).optional()
+});
+
+// src/service/task.service.ts
+var TaskServiceImpl = class {
+  constructor(repo, projectService, getDependencyService) {
+    this.repo = repo;
+    this.projectService = projectService;
+    this.getDependencyService = getDependencyService;
+  }
+  repo;
+  projectService;
+  getDependencyService;
+  createTask(input, projectIdOrName) {
+    return logger.startSpan("TaskService.createTask", () => {
+      const parsed = CreateTaskSchema.safeParse(input);
+      if (!parsed.success) {
+        return err(new AppError("VALIDATION", parsed.error.message));
+      }
+      const projectRef = parsed.data.projectId ?? projectIdOrName;
+      const projectResult = this.projectService.resolveProject(projectRef);
+      if (!projectResult.ok) return projectResult;
+      if (parsed.data.parentId) {
+        const parentResult = this.repo.findById(parsed.data.parentId);
+        if (!parentResult.ok) return parentResult;
+        if (!parentResult.value) {
+          return err(new AppError("NOT_FOUND", `Parent task not found: ${parsed.data.parentId}`));
+        }
+      }
+      const project = projectResult.value;
+      const taskIdResult = this.projectService.nextTaskId(project);
+      if (!taskIdResult.ok) return taskIdResult;
+      const insertResult = this.repo.insert(taskIdResult.value, {
+        ...parsed.data,
+        projectId: project.id
+      });
+      if (!insertResult.ok) return insertResult;
+      if (parsed.data.dependsOn && parsed.data.dependsOn.length > 0) {
+        for (const entry of parsed.data.dependsOn) {
+          const depResult = this.getDependencyService().addDependency({
+            taskId: insertResult.value.id,
+            dependsOnId: entry.id,
+            type: entry.type
+          });
+          if (!depResult.ok) return depResult;
+        }
+      }
+      return insertResult;
+    });
+  }
+  getTask(id) {
+    return logger.startSpan("TaskService.getTask", () => {
+      const result = this.repo.findById(id);
+      if (!result.ok) return result;
+      if (!result.value) {
+        return err(new AppError("NOT_FOUND", `Task not found: ${id}`));
+      }
+      return ok(result.value);
+    });
+  }
+  listTasks(filter) {
+    return logger.startSpan("TaskService.listTasks", () => {
+      const parsed = TaskFilterSchema.safeParse(filter);
+      if (!parsed.success) {
+        return err(new AppError("VALIDATION", parsed.error.message));
+      }
+      let resolvedFilter = parsed.data;
+      if (parsed.data.projectId) {
+        const projectResult = this.projectService.resolveProject(parsed.data.projectId);
+        if (!projectResult.ok) return projectResult;
+        resolvedFilter = { ...resolvedFilter, projectId: projectResult.value.id };
+      }
+      return this.repo.findMany(resolvedFilter);
+    });
+  }
+  updateTask(id, input) {
+    return logger.startSpan("TaskService.updateTask", () => {
+      const parsed = UpdateTaskSchema.safeParse(input);
+      if (!parsed.success) {
+        return err(new AppError("VALIDATION", parsed.error.message));
+      }
+      if (parsed.data.status === TaskStatus.InProgress) {
+        const blockersResult = this.getDependencyService().listBlockers(id);
+        if (!blockersResult.ok) return blockersResult;
+        const hasNonTerminalBlocker = blockersResult.value.some((b) => !isTerminalStatus(b.status));
+        if (hasNonTerminalBlocker) {
+          return err(
+            new AppError("VALIDATION", "Task is blocked by unfinished dependencies")
+          );
+        }
+      }
+      if (parsed.data.status && isTerminalStatus(parsed.data.status)) {
+        const existingResult = this.repo.findById(id);
+        if (!existingResult.ok) return existingResult;
+        if (!existingResult.value) {
+          return err(new AppError("NOT_FOUND", `Task not found: ${id}`));
+        }
+        const existing = existingResult.value;
+        const updateResult = this.repo.update(id, parsed.data);
+        if (!updateResult.ok) return updateResult;
+        if (!isTerminalStatus(existing.status)) {
+          const maxRankResult = this.repo.getMaxRank(existing.projectId);
+          if (!maxRankResult.ok) return maxRankResult;
+          return this.repo.rerank(id, maxRankResult.value + RANK_GAP);
+        }
+        return updateResult;
+      }
+      return this.repo.update(id, parsed.data);
+    });
+  }
+  deleteTask(id) {
+    return this.repo.delete(id);
+  }
+  breakdownTask(parentId, subtasks) {
+    return logger.startSpan("TaskService.breakdownTask", () => {
+      const parentResult = this.repo.findById(parentId);
+      if (!parentResult.ok) return parentResult;
+      if (!parentResult.value) {
+        return err(new AppError("NOT_FOUND", `Parent task not found: ${parentId}`));
+      }
+      const parent = parentResult.value;
+      const projectResult = this.projectService.resolveProject(parent.projectId);
+      if (!projectResult.ok) return projectResult;
+      const project = projectResult.value;
+      const created = [];
+      for (const subtask of subtasks) {
+        const parsed = CreateTaskSchema.safeParse(subtask);
+        if (!parsed.success) {
+          return err(new AppError("VALIDATION", `Invalid subtask: ${parsed.error.message}`));
+        }
+        const taskIdResult = this.projectService.nextTaskId(project);
+        if (!taskIdResult.ok) return taskIdResult;
+        const result = this.repo.insert(taskIdResult.value, {
+          ...parsed.data,
+          projectId: parent.projectId,
+          parentId
+        });
+        if (!result.ok) return result;
+        created.push(result.value);
+      }
+      return ok(created);
+    });
+  }
+  /**
+   * Re-rank a task using Jira-style ranking:
+   * - afterId: place the task immediately after the given task
+   * - beforeId: place the task immediately before the given task
+   * - position: place the task at the given 1-based position in the backlog
+   *
+   * New rank is computed as the midpoint between neighbors.
+   * If moving to the top, rank = first_rank - GAP.
+   * If moving to the bottom, rank = last_rank + GAP.
+   */
+  rerankTask(input, projectIdOrName) {
+    return logger.startSpan("TaskService.rerankTask", () => {
+      const parsed = RerankTaskSchema.safeParse(input);
+      if (!parsed.success) {
+        return err(new AppError("VALIDATION", parsed.error.message));
+      }
+      const { taskId, afterId, beforeId, position } = parsed.data;
+      const specifiedCount = [afterId, beforeId, position].filter((v) => v !== void 0).length;
+      if (specifiedCount !== 1) {
+        return err(
+          new AppError(
+            "VALIDATION",
+            "Exactly one of --after, --before, or --position must be specified"
+          )
+        );
+      }
+      const taskResult = this.repo.findById(taskId);
+      if (!taskResult.ok) return taskResult;
+      if (!taskResult.value) {
+        return err(new AppError("NOT_FOUND", `Task not found: ${taskId}`));
+      }
+      const task = taskResult.value;
+      if (isTerminalStatus(task.status)) {
+        return err(
+          new AppError(
+            "VALIDATION",
+            `Cannot rerank a task with status '${task.status}'. Only active tasks can be reranked.`
+          )
+        );
+      }
+      const projectRef = projectIdOrName ?? task.projectId;
+      const projectResult = this.projectService.resolveProject(projectRef);
+      if (!projectResult.ok) return projectResult;
+      const projectId = projectResult.value.id;
+      const rankedResult = this.repo.getRankedTasks(projectId, TaskStatus.Backlog);
+      if (!rankedResult.ok) return rankedResult;
+      const ranked = rankedResult.value.filter((t) => t.id !== taskId);
+      let newRank;
+      if (afterId) {
+        const anchor = ranked.find((t) => t.id === afterId);
+        if (!anchor) {
+          return err(new AppError("NOT_FOUND", `Anchor task not found in backlog: ${afterId}`));
+        }
+        const anchorIndex = ranked.indexOf(anchor);
+        const next = ranked[anchorIndex + 1];
+        newRank = next ? (anchor.rank + next.rank) / 2 : anchor.rank + RANK_GAP;
+      } else if (beforeId) {
+        const anchor = ranked.find((t) => t.id === beforeId);
+        if (!anchor) {
+          return err(new AppError("NOT_FOUND", `Anchor task not found in backlog: ${beforeId}`));
+        }
+        const anchorIndex = ranked.indexOf(anchor);
+        const prev = ranked[anchorIndex - 1];
+        newRank = prev ? (prev.rank + anchor.rank) / 2 : anchor.rank - RANK_GAP;
+      } else {
+        const pos = position;
+        if (pos < 1) {
+          return err(new AppError("VALIDATION", "Position must be >= 1"));
+        }
+        if (pos === 1) {
+          const first = ranked[0];
+          newRank = first ? first.rank - RANK_GAP : RANK_GAP;
+        } else if (pos > ranked.length) {
+          const last = ranked[ranked.length - 1];
+          newRank = last ? last.rank + RANK_GAP : RANK_GAP;
+        } else {
+          const above = ranked[pos - 2];
+          const below = ranked[pos - 1];
+          if (!above || !below) {
+            return err(new AppError("DB_ERROR", "Unexpected missing neighbor tasks"));
+          }
+          newRank = (above.rank + below.rank) / 2;
+        }
+      }
+      const depService = this.getDependencyService();
+      const blockersResult = depService.listBlockers(taskId);
+      if (blockersResult.ok) {
+        for (const blocker of blockersResult.value) {
+          if (blocker.projectId === projectId && newRank < blocker.rank) {
+            return err(
+              new AppError(
+                "VALIDATION",
+                `Cannot rank above blocker "${blocker.id}" (${blocker.name}). Complete or remove the dependency first.`
+              )
+            );
+          }
+        }
+      }
+      const dependentsResult = depService.listDependents(taskId);
+      if (dependentsResult.ok) {
+        for (const dep of dependentsResult.value) {
+          if (dep.projectId === projectId && newRank > dep.rank) {
+            return err(
+              new AppError(
+                "VALIDATION",
+                `Cannot rank below dependent "${dep.id}" (${dep.name}). Complete or remove the dependency first.`
+              )
+            );
+          }
+        }
+      }
+      return this.repo.rerank(taskId, newRank);
+    });
+  }
+  searchTasks(query, projectIdOrName) {
+    return logger.startSpan("TaskService.searchTasks", () => {
+      if (!query.trim()) {
+        return err(new AppError("VALIDATION", "Search query cannot be empty"));
+      }
+      let projectId;
+      if (projectIdOrName) {
+        const projectResult = this.projectService.resolveProject(projectIdOrName);
+        if (!projectResult.ok) return projectResult;
+        projectId = projectResult.value.id;
+      }
+      return this.repo.search(query, projectId);
+    });
+  }
+};
+
+// src/types/dependency.ts
+import { z as z3 } from "zod/v4";
+var dbDepTypeValues = [
+  DependencyType.Blocks,
+  DependencyType.RelatesTo,
+  DependencyType.Duplicates
+];
+var AddDependencySchema = z3.object({
+  taskId: z3.string().min(1, "Task id is required"),
+  dependsOnId: z3.string().min(1, "Depends-on task id is required"),
+  type: z3.enum(dbDepTypeValues).default(DependencyType.Blocks)
+});
+var RemoveDependencySchema = z3.object({
+  taskId: z3.string().min(1, "Task id is required"),
+  dependsOnId: z3.string().min(1, "Depends-on task id is required")
+});
+
+// src/service/dependency.service.ts
+var DependencyServiceImpl = class {
+  constructor(depRepo, taskRepo) {
+    this.depRepo = depRepo;
+    this.taskRepo = taskRepo;
+  }
+  depRepo;
+  taskRepo;
+  requireTask(taskId) {
+    const result = this.taskRepo.findById(taskId);
+    if (!result.ok) return result;
+    if (!result.value) {
+      return err(new AppError("NOT_FOUND", `Task not found: ${taskId}`));
+    }
+    return ok(result.value);
+  }
+  addDependency(input) {
+    return logger.startSpan("DependencyService.addDependency", () => {
+      const normalized = normalizeBlockedBy(input);
+      const parsed = AddDependencySchema.safeParse(normalized);
+      if (!parsed.success) {
+        return err(new AppError("VALIDATION", parsed.error.message));
+      }
+      const { taskId, dependsOnId, type } = parsed.data;
+      const taskResult = this.requireTask(taskId);
+      if (!taskResult.ok) return taskResult;
+      const depResult = this.requireTask(dependsOnId);
+      if (!depResult.ok) return depResult;
+      const cycleResult = this.depRepo.wouldCreateCycle(taskId, dependsOnId);
+      if (!cycleResult.ok) return cycleResult;
+      if (cycleResult.value) {
+        return err(
+          new AppError(
+            "VALIDATION",
+            `Adding this dependency would create a cycle: ${taskId} -> ${dependsOnId}`
+          )
+        );
+      }
+      return this.depRepo.insert(taskId, dependsOnId, type);
+    });
+  }
+  removeDependency(input) {
+    return logger.startSpan("DependencyService.removeDependency", () => {
+      const parsed = RemoveDependencySchema.safeParse(input);
+      if (!parsed.success) {
+        return err(new AppError("VALIDATION", parsed.error.message));
+      }
+      return this.depRepo.delete(parsed.data.taskId, parsed.data.dependsOnId);
+    });
+  }
+  removeDependencyBetween(taskId, otherId) {
+    return logger.startSpan("DependencyService.removeDependencyBetween", () => {
+      const forward = this.depRepo.delete(taskId, otherId);
+      if (forward.ok) return forward;
+      return this.depRepo.delete(otherId, taskId);
+    });
+  }
+  listBlockers(taskId) {
+    return this.depRepo.getBlockers(taskId);
+  }
+  listDependents(taskId) {
+    return this.depRepo.getDependents(taskId);
+  }
+  listRelated(taskId) {
+    return this.depRepo.getRelated(taskId);
+  }
+  listDuplicates(taskId) {
+    return this.depRepo.getDuplicates(taskId);
+  }
+  listAllDeps(taskId) {
+    return this.depRepo.findByTask(taskId);
+  }
+  getTransitiveDeps(taskId) {
+    return this.depRepo.getTransitiveClosure(taskId);
+  }
+  buildGraph(taskId) {
+    return logger.startSpan("DependencyService.buildGraph", () => {
+      const taskResult = this.taskRepo.findById(taskId);
+      if (!taskResult.ok) return taskResult;
+      if (!taskResult.value) {
+        return err(new AppError("NOT_FOUND", `Task not found: ${taskId}`));
+      }
+      const rootTask = taskResult.value;
+      const visited = /* @__PURE__ */ new Map();
+      const allEdges = [];
+      const queue = [taskId];
+      visited.set(taskId, rootTask);
+      while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) break;
+        const blockersResult = this.depRepo.findByTask(current);
+        if (!blockersResult.ok) return blockersResult;
+        for (const dep of blockersResult.value) {
+          allEdges.push({ from: dep.taskId, to: dep.dependsOnId, type: dep.type });
+          if (!visited.has(dep.dependsOnId)) {
+            const t = this.taskRepo.findById(dep.dependsOnId);
+            if (!t.ok) return t;
+            if (t.value) {
+              visited.set(dep.dependsOnId, t.value);
+              queue.push(dep.dependsOnId);
+            }
+          }
+        }
+        const dependentsResult = this.depRepo.findDependents(current);
+        if (!dependentsResult.ok) return dependentsResult;
+        for (const dep of dependentsResult.value) {
+          allEdges.push({ from: dep.taskId, to: dep.dependsOnId, type: dep.type });
+          if (!visited.has(dep.taskId)) {
+            const t = this.taskRepo.findById(dep.taskId);
+            if (!t.ok) return t;
+            if (t.value) {
+              visited.set(dep.taskId, t.value);
+              queue.push(dep.taskId);
+            }
+          }
+        }
+      }
+      const edgeSet = /* @__PURE__ */ new Set();
+      const uniqueEdges = [];
+      for (const edge of allEdges) {
+        const key = `${edge.from}->${edge.to}`;
+        if (!edgeSet.has(key)) {
+          edgeSet.add(key);
+          uniqueEdges.push(edge);
+        }
+      }
+      const nodes = Array.from(visited.values());
+      const mermaid = this.toMermaid(nodes, uniqueEdges, taskId);
+      return ok({ nodes, edges: uniqueEdges, mermaid });
+    });
+  }
+  toMermaid(nodes, edges, highlightId) {
+    const lines = ["graph LR"];
+    for (const node of nodes) {
+      const label = `${node.id}: ${node.name} [${node.status}]`;
+      const escaped = label.replace(/"/g, "#quot;");
+      if (node.id === highlightId) {
+        lines.push(`  ${node.id}("${escaped}"):::highlight`);
+      } else {
+        lines.push(`  ${node.id}["${escaped}"]`);
+      }
+    }
+    for (const edge of edges) {
+      const label = edge.type === "blocks" ? "blocks" : edge.type;
+      lines.push(`  ${edge.from} -->|${label}| ${edge.to}`);
+    }
+    lines.push("  classDef highlight fill:#f9f,stroke:#333,stroke-width:2px");
+    return lines.join("\n");
+  }
+};
+function normalizeBlockedBy(input) {
+  if (typeof input === "object" && input !== null && "type" in input && input.type === UIDependencyType.BlockedBy) {
+    const { taskId, dependsOnId, ...rest } = input;
+    return { ...rest, taskId: dependsOnId, dependsOnId: taskId, type: DependencyType.Blocks };
+  }
+  return input;
+}
+
+// src/types/portability.ts
+import { z as z4 } from "zod/v4";
+var ImportFileSchema = z4.object({
+  version: z4.number().optional(),
+  tasks: z4.array(z4.record(z4.string(), z4.unknown())).min(1, "At least one task is required"),
+  dependencies: z4.array(z4.record(z4.string(), z4.unknown())).optional().default([])
+});
+function parseFieldMapping(raw) {
+  const mapping = /* @__PURE__ */ new Map();
+  for (const pair of raw.split(",")) {
+    const parts = pair.split(":").map((s) => s.trim());
+    if (parts.length === 2 && parts[0] && parts[1]) {
+      mapping.set(parts[0], parts[1]);
+    }
+  }
+  return mapping;
+}
+
+// src/service/portability.service.ts
+var PortabilityServiceImpl = class {
+  constructor(taskService, depService, projectService) {
+    this.taskService = taskService;
+    this.depService = depService;
+    this.projectService = projectService;
+  }
+  taskService;
+  depService;
+  projectService;
+  exportTasks(projectIdOrName) {
+    return logger.startSpan("PortabilityService.exportTasks", () => {
+      const projectResult = this.projectService.resolveProject(projectIdOrName);
+      if (!projectResult.ok) return projectResult;
+      const project = projectResult.value;
+      const tasksResult = this.taskService.listTasks({ projectId: project.id });
+      if (!tasksResult.ok) return tasksResult;
+      const tasks = tasksResult.value;
+      const taskIds = new Set(tasks.map((t) => t.id));
+      const exportTasks = tasks.map((t) => ({
+        id: t.id,
+        name: t.name,
+        description: t.description,
+        type: t.type,
+        status: t.status,
+        parentId: t.parentId,
+        technicalNotes: t.technicalNotes,
+        additionalRequirements: t.additionalRequirements,
+        rank: t.rank
+      }));
+      const allDeps = [];
+      for (const task of tasks) {
+        const depsResult = this.depService.listAllDeps(task.id);
+        if (!depsResult.ok) return depsResult;
+        for (const dep of depsResult.value) {
+          if (taskIds.has(dep.dependsOnId)) {
+            allDeps.push({
+              taskId: dep.taskId,
+              dependsOnId: dep.dependsOnId,
+              type: dep.type
+            });
+          }
+        }
+      }
+      logger.info("Exported tasks", {
+        project: project.key,
+        tasks: tasks.length,
+        dependencies: allDeps.length
+      });
+      return ok({
+        version: 1,
+        exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        tasks: exportTasks,
+        dependencies: allDeps
+      });
+    });
+  }
+  importTasks(fileData, projectIdOrName, fieldMapping) {
+    return logger.startSpan("PortabilityService.importTasks", () => {
+      const parsed = ImportFileSchema.safeParse(fileData);
+      if (!parsed.success) {
+        return err(new AppError("VALIDATION", parsed.error.message));
+      }
+      const reverseMap = this.buildReverseMap(fieldMapping);
+      const mappedTasks = [];
+      for (const sourceTask of parsed.data.tasks) {
+        const mapped = this.mapTaskFields(sourceTask, reverseMap);
+        if (!mapped.ok) return mapped;
+        mappedTasks.push(mapped.value);
+      }
+      const mappedDeps = [];
+      for (const sourceDep of parsed.data.dependencies) {
+        const mapped = this.mapDependencyFields(sourceDep, reverseMap);
+        if (!mapped.ok) return mapped;
+        mappedDeps.push(mapped.value);
+      }
+      const sorted = this.topoSortByParent(mappedTasks);
+      const idMap = /* @__PURE__ */ new Map();
+      for (const task of sorted) {
+        let parentId;
+        if (task.parentId) {
+          parentId = idMap.get(task.parentId) ?? task.parentId;
+        }
+        const createResult = this.taskService.createTask(
+          {
+            name: task.name,
+            description: task.description || void 0,
+            type: task.type || void 0,
+            status: task.status || void 0,
+            parentId,
+            technicalNotes: task.technicalNotes || void 0,
+            additionalRequirements: task.additionalRequirements || void 0
+          },
+          projectIdOrName
+        );
+        if (!createResult.ok) return createResult;
+        idMap.set(task.sourceId, createResult.value.id);
+        logger.info("Imported task", {
+          sourceId: task.sourceId,
+          newId: createResult.value.id
+        });
+      }
+      let depCount = 0;
+      for (const dep of mappedDeps) {
+        const taskId = idMap.get(dep.sourceTaskId) ?? dep.sourceTaskId;
+        const dependsOnId = idMap.get(dep.sourceDependsOnId) ?? dep.sourceDependsOnId;
+        const depResult = this.depService.addDependency({
+          taskId,
+          dependsOnId,
+          type: dep.type || void 0
+        });
+        if (!depResult.ok) return depResult;
+        depCount++;
+        logger.info("Imported dependency", { from: taskId, to: dependsOnId });
+      }
+      const idMapObj = {};
+      for (const [k, v] of idMap) {
+        idMapObj[k] = v;
+      }
+      logger.info("Import completed", {
+        tasks: mappedTasks.length,
+        dependencies: depCount
+      });
+      return ok({
+        imported: mappedTasks.length,
+        dependencies: depCount,
+        idMap: idMapObj
+      });
+    });
+  }
+  // ── Private helpers ───────────────────────────────────────────────
+  /** Invert the user-provided mapping (source→target) into (target→source). */
+  buildReverseMap(fieldMapping) {
+    const reverse = /* @__PURE__ */ new Map();
+    if (!fieldMapping) return reverse;
+    for (const [source, target] of fieldMapping) {
+      reverse.set(target, source);
+    }
+    return reverse;
+  }
+  /** Read a field from a source object, checking reverse-mapped name first, then literal name. */
+  getField(source, field, reverseMap) {
+    const sourceField = reverseMap.get(field) ?? field;
+    const value = source[sourceField];
+    if (value == null) return "";
+    if (typeof value === "string") return value;
+    if (typeof value === "number" || typeof value === "boolean") return `${value}`;
+    return JSON.stringify(value);
+  }
+  mapTaskFields(source, reverseMap) {
+    const sourceId = this.getField(source, "id", reverseMap);
+    const name = this.getField(source, "name", reverseMap);
+    if (!sourceId) {
+      return err(new AppError("VALIDATION", "Each imported task must have an id"));
+    }
+    if (!name) {
+      return err(
+        new AppError("VALIDATION", `Imported task '${sourceId}' is missing required field 'name'`)
+      );
+    }
+    return ok({
+      sourceId,
+      name,
+      description: this.getField(source, "description", reverseMap),
+      type: this.getField(source, "type", reverseMap),
+      status: this.getField(source, "status", reverseMap),
+      parentId: this.getField(source, "parentId", reverseMap) || null,
+      technicalNotes: this.getField(source, "technicalNotes", reverseMap),
+      additionalRequirements: this.getField(source, "additionalRequirements", reverseMap)
+    });
+  }
+  mapDependencyFields(source, reverseMap) {
+    const taskId = this.getField(source, "taskId", reverseMap);
+    const dependsOnId = this.getField(source, "dependsOnId", reverseMap);
+    if (!taskId || !dependsOnId) {
+      return err(new AppError("VALIDATION", "Each dependency must have taskId and dependsOnId"));
+    }
+    return ok({
+      sourceTaskId: taskId,
+      sourceDependsOnId: dependsOnId,
+      type: this.getField(source, "type", reverseMap)
+    });
+  }
+  /**
+   * Sort tasks so that parents come before children within the import set.
+   * Tasks whose parentId is outside the import set are treated as roots.
+   */
+  topoSortByParent(tasks) {
+    const sourceIds = new Set(tasks.map((t) => t.sourceId));
+    const sorted = [];
+    const remaining = new Set(tasks);
+    const created = /* @__PURE__ */ new Set();
+    while (remaining.size > 0) {
+      const batch = [];
+      for (const task of remaining) {
+        const parentInImport = task.parentId !== null && sourceIds.has(task.parentId);
+        if (!parentInImport || task.parentId !== null && created.has(task.parentId)) {
+          batch.push(task);
+        }
+      }
+      if (batch.length === 0) {
+        logger.warn("Circular parent references detected during import, forcing remaining tasks");
+        for (const t of remaining) {
+          sorted.push(t);
+        }
+        break;
+      }
+      for (const t of batch) {
+        remaining.delete(t);
+        created.add(t.sourceId);
+        sorted.push(t);
+      }
+    }
+    return sorted;
+  }
+};
+
+// src/cli/container.ts
+function createContainer(db) {
+  const projectRepo = new SqliteProjectRepository(db);
+  const taskRepo = new SqliteTaskRepository(db);
+  const depRepo = new SqliteDependencyRepository(db);
+  const projectService = new ProjectServiceImpl(projectRepo);
+  const dependencyService = new DependencyServiceImpl(depRepo, taskRepo);
+  const taskService = new TaskServiceImpl(taskRepo, projectService, () => dependencyService);
+  const portabilityService = new PortabilityServiceImpl(
+    taskService,
+    dependencyService,
+    projectService
+  );
+  return { projectService, taskService, dependencyService, portabilityService };
+}
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/output.ts
+function printSuccess(data) {
+  process.stdout.write(JSON.stringify({ ok: true, data }, null, 2) + "\n");
+}
+function printError(error) {
+  process.stderr.write(
+    JSON.stringify({ ok: false, error: { code: error.code, message: error.message } }, null, 2) + "\n"
+  );
+  process.exit(1);
+}
+function handleResult(result) {
+  if (result.ok) {
+    printSuccess(result.value);
+  } else {
+    printError(result.error);
+  }
+}
+
+// src/cli/commands/project/create.ts
+function registerProjectCreate(parent, container) {
+  parent.command("create").description("Create a new project").requiredOption("-n, --name <name>", "Project name").option(
+    "-k, --key <key>",
+    "Project key (2-10 alphanumeric chars, defaults to first 3 chars of name)"
+  ).option("-d, --description <description>", "Project description").option("--default", "Set as default project").action((opts) => {
+    const result = container.projectService.createProject({
+      name: opts.name,
+      key: opts.key,
+      description: opts.description,
+      isDefault: opts.default
+    });
+    handleResult(result);
+  });
+}
+
+// src/cli/commands/project/list.ts
+function registerProjectList(parent, container) {
+  parent.command("list").description("List all projects").action(() => {
+    const result = container.projectService.listProjects();
+    handleResult(result);
+  });
+}
+
+// src/cli/commands/project/update.ts
+function registerProjectUpdate(parent, container) {
+  parent.command("update <idOrKeyOrName>").description("Update a project (lookup by id, key, or name)").option("-n, --name <name>", "Project name").option("-d, --description <description>", "Project description").option("--default", "Set as default project").action(
+    (idOrKeyOrName, opts) => {
+      const resolved = container.projectService.resolveProject(idOrKeyOrName);
+      if (!resolved.ok) {
+        handleResult(resolved);
+        return;
+      }
+      const result = container.projectService.updateProject(resolved.value.id, {
+        name: opts.name,
+        description: opts.description,
+        isDefault: opts.default
+      });
+      handleResult(result);
+    }
+  );
+}
+
+// src/cli/commands/project/delete.ts
+function registerProjectDelete(parent, container) {
+  parent.command("delete <idOrKeyOrName>").description("Delete a project (lookup by id, key, or name)").action((idOrKeyOrName) => {
+    const resolved = container.projectService.resolveProject(idOrKeyOrName);
+    if (!resolved.ok) {
+      handleResult(resolved);
+      return;
+    }
+    const result = container.projectService.deleteProject(resolved.value.id);
+    handleResult(result);
+  });
+}
+
+// src/cli/commands/project/set-default.ts
+function registerProjectSetDefault(parent, container) {
+  parent.command("set-default <idOrKeyOrName>").description("Set a project as the default (lookup by id, key, or name)").action((idOrKeyOrName) => {
+    const resolved = container.projectService.resolveProject(idOrKeyOrName);
+    if (!resolved.ok) {
+      handleResult(resolved);
+      return;
+    }
+    const result = container.projectService.updateProject(resolved.value.id, {
+      isDefault: true
+    });
+    handleResult(result);
+  });
+}
+
+// src/cli/commands/task/create.ts
+function registerTaskCreate(parent, container) {
+  parent.command("create").description("Create a new task (appended to bottom of backlog)").requiredOption("-n, --name <name>", "Task name").option("-p, --project <project>", "Project id or name").option("-d, --description <description>", "Task description").option("-t, --type <type>", "Task type: story, tech-debt, bug", "story").option("-s, --status <status>", "Task status", "backlog").option("--parent <parentId>", "Parent task id for subtask").option("--technical-notes <notes>", "Technical notes (markdown)").option("--additional-requirements <requirements>", "Additional requirements (markdown)").option("--depends-on <ids...>", "Task ids this task depends on (blocks relationship)").action(
+    (opts) => {
+      const result = container.taskService.createTask(
+        {
+          name: opts.name,
+          description: opts.description,
+          type: opts.type,
+          status: opts.status,
+          parentId: opts.parent,
+          technicalNotes: opts.technicalNotes,
+          additionalRequirements: opts.additionalRequirements,
+          dependsOn: opts.dependsOn?.map((id) => ({ id }))
+        },
+        opts.project
+      );
+      handleResult(result);
+    }
+  );
+}
+
+// src/cli/commands/task/list.ts
+function registerTaskList(parent, container) {
+  parent.command("list").description("List tasks in rank order (defaults to backlog)").option("-p, --project <project>", "Filter by project id or name").option("-s, --status <status>", "Filter by status (default: backlog)").option("-t, --type <type>", "Filter by type").option("--parent <parentId>", "Filter by parent task id").option("--search <text>", "Search in name, description, and notes").action(
+    (opts) => {
+      const result = container.taskService.listTasks({
+        projectId: opts.project,
+        status: opts.status ?? "backlog",
+        type: opts.type,
+        parentId: opts.parent,
+        search: opts.search
+      });
+      handleResult(result);
+    }
+  );
+}
+
+// src/cli/commands/task/show.ts
+function registerTaskShow(parent, container) {
+  parent.command("show <id>").description("Show task details").action((id) => {
+    const result = container.taskService.getTask(id);
+    handleResult(result);
+  });
+}
+
+// src/cli/commands/task/update.ts
+function registerTaskUpdate(parent, container) {
+  parent.command("update <id>").description("Update a task").option("-n, --name <name>", "Task name").option("-d, --description <description>", "Task description").option("-t, --type <type>", "Task type: story, tech-debt, bug").option("-s, --status <status>", "Task status").option("--parent <parentId>", "Parent task id").option("--technical-notes <notes>", "Replace technical notes").option("--additional-requirements <requirements>", "Replace additional requirements").option("--append-notes <notes>", "Append to technical notes").option("--append-requirements <requirements>", "Append to additional requirements").action(
+    (id, opts) => {
+      const result = container.taskService.updateTask(id, {
+        name: opts.name,
+        description: opts.description,
+        type: opts.type,
+        status: opts.status,
+        parentId: opts.parent,
+        technicalNotes: opts.technicalNotes,
+        additionalRequirements: opts.additionalRequirements,
+        appendNotes: opts.appendNotes,
+        appendRequirements: opts.appendRequirements
+      });
+      handleResult(result);
+    }
+  );
+}
+
+// src/cli/commands/task/delete.ts
+function registerTaskDelete(parent, container) {
+  parent.command("delete <id>").description("Delete a task").action((id) => {
+    const result = container.taskService.deleteTask(id);
+    handleResult(result);
+  });
+}
+
+// src/cli/commands/task/breakdown.ts
+import { readFileSync as readFileSync2 } from "fs";
+function registerTaskBreakdown(parent, container) {
+  parent.command("breakdown <parentId>").description("Create subtasks from a JSON file").requiredOption("-f, --file <path>", "JSON file with array of subtask definitions").action((parentId, opts) => {
+    let content;
+    try {
+      content = readFileSync2(opts.file, "utf-8");
+    } catch (e) {
+      return printError(
+        new AppError("VALIDATION", `Failed to read subtasks file: ${opts.file}`, e)
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch (e) {
+      return printError(
+        new AppError("VALIDATION", `Invalid JSON in subtasks file: ${opts.file}`, e)
+      );
+    }
+    if (!Array.isArray(parsed)) {
+      return printError(new AppError("VALIDATION", "File must contain a JSON array of subtasks"));
+    }
+    handleResult(container.taskService.breakdownTask(parentId, parsed));
+  });
+}
+
+// src/cli/commands/task/rank.ts
+function registerTaskRank(parent, container) {
+  parent.command("rank <id>").description("Re-rank a task in the backlog (Jira-style positioning)").option("--after <taskId>", "Place immediately after this task").option("--before <taskId>", "Place immediately before this task").option("--position <n>", "Place at 1-based position in backlog").option("-p, --project <project>", "Project id or name").action(
+    (id, opts) => {
+      const result = container.taskService.rerankTask(
+        {
+          taskId: id,
+          afterId: opts.after,
+          beforeId: opts.before,
+          position: opts.position ? parseInt(opts.position, 10) : void 0
+        },
+        opts.project
+      );
+      handleResult(result);
+    }
+  );
+}
+
+// src/cli/commands/task/search.ts
+function registerTaskSearch(parent, container) {
+  parent.command("search <query>").description("Full-text search tasks with relevance ranking (FTS5)").option("-p, --project <project>", "Limit search to a project").action((query, opts) => {
+    const result = container.taskService.searchTasks(query, opts.project);
+    handleResult(result);
+  });
+}
+
+// src/cli/commands/task/export.ts
+import { writeFileSync } from "fs";
+function registerTaskExport(parent, container) {
+  parent.command("export").description("Export tasks to JSON file").option("-p, --project <project>", "Project id or name").option("-o, --output <file>", "Output file path (defaults to stdout)").action((opts) => {
+    const result = container.portabilityService.exportTasks(opts.project);
+    if (!result.ok) {
+      return printError(result.error);
+    }
+    if (opts.output) {
+      try {
+        writeFileSync(opts.output, JSON.stringify(result.value, null, 2) + "\n", "utf-8");
+      } catch (e) {
+        return printError(new AppError("UNKNOWN", `Failed to write file: ${opts.output}`, e));
+      }
+      printSuccess({
+        file: opts.output,
+        tasks: result.value.tasks.length,
+        dependencies: result.value.dependencies.length
+      });
+    } else {
+      printSuccess(result.value);
+    }
+  });
+}
+
+// src/cli/commands/task/import.ts
+import { readFileSync as readFileSync3 } from "fs";
+function registerTaskImport(parent, container) {
+  parent.command("import").description("Import tasks from JSON file").requiredOption("-f, --file <file>", "Input JSON file path").option("-p, --project <project>", "Target project id or name").option(
+    "--map <mapping>",
+    'Field mapping as comma-separated source:target pairs (e.g. "title:name,summary:description")'
+  ).action((opts) => {
+    let fileData;
+    try {
+      const raw = readFileSync3(opts.file, "utf-8");
+      fileData = JSON.parse(raw);
+    } catch (e) {
+      return printError(
+        new AppError(
+          "VALIDATION",
+          `Failed to read or parse file: ${opts.file}${e instanceof Error ? ` - ${e.message}` : ""}`
+        )
+      );
+    }
+    const fieldMapping = opts.map ? parseFieldMapping(opts.map) : void 0;
+    const result = container.portabilityService.importTasks(fileData, opts.project, fieldMapping);
+    handleResult(result);
+  });
+}
+
+// src/cli/commands/dep/add.ts
+function registerDepAdd(parent, container) {
+  parent.command("add <taskId> <dependsOnId>").description("Add a dependency (taskId depends on dependsOnId)").option(
+    "-t, --type <type>",
+    "Dependency type: blocks, relates-to, duplicates, blocked-by",
+    "blocks"
+  ).action((taskId, dependsOnId, opts) => {
+    const result = container.dependencyService.addDependency({
+      taskId,
+      dependsOnId,
+      type: opts.type
+    });
+    handleResult(result);
+  });
+}
+
+// src/cli/commands/dep/remove.ts
+function registerDepRemove(parent, container) {
+  parent.command("remove <taskId> <dependsOnId>").description("Remove a dependency").action((taskId, dependsOnId) => {
+    const result = container.dependencyService.removeDependency({
+      taskId,
+      dependsOnId
+    });
+    handleResult(result);
+  });
+}
+
+// src/cli/commands/dep/list.ts
+function registerDepList(parent, container) {
+  parent.command("list <taskId>").description("List direct dependencies of a task").option("--blockers", "Show tasks that block this task").option("--dependents", "Show tasks that depend on this task").option("--transitive", "Show all transitive blockers (deep)").action(
+    (taskId, opts) => {
+      if (opts.transitive) {
+        handleResult(container.dependencyService.getTransitiveDeps(taskId));
+      } else if (opts.dependents) {
+        handleResult(container.dependencyService.listDependents(taskId));
+      } else if (opts.blockers) {
+        handleResult(container.dependencyService.listBlockers(taskId));
+      } else {
+        handleResult(container.dependencyService.listAllDeps(taskId));
+      }
+    }
+  );
+}
+
+// src/cli/commands/dep/graph.ts
+function registerDepGraph(parent, container) {
+  parent.command("graph <taskId>").description("Build full dependency graph centered on a task (outputs Mermaid)").action((taskId) => {
+    const result = container.dependencyService.buildGraph(taskId);
+    handleResult(result);
+  });
+}
+
+// src/cli/index.ts
+function buildCLI(container) {
+  const program = new Command();
+  program.name("tayto").description("CLI task management for solo devs and AI agents").version("0.1.0");
+  const project = program.command("project").description("Manage projects");
+  registerProjectCreate(project, container);
+  registerProjectList(project, container);
+  registerProjectUpdate(project, container);
+  registerProjectDelete(project, container);
+  registerProjectSetDefault(project, container);
+  const task = program.command("task").description("Manage tasks");
+  registerTaskCreate(task, container);
+  registerTaskList(task, container);
+  registerTaskShow(task, container);
+  registerTaskUpdate(task, container);
+  registerTaskDelete(task, container);
+  registerTaskBreakdown(task, container);
+  registerTaskRank(task, container);
+  registerTaskSearch(task, container);
+  registerTaskExport(task, container);
+  registerTaskImport(task, container);
+  const dep = program.command("dep").description("Manage task dependencies");
+  registerDepAdd(dep, container);
+  registerDepRemove(dep, container);
+  registerDepList(dep, container);
+  registerDepGraph(dep, container);
+  program.command("tui").description("Launch interactive terminal UI").option("-p, --project <project>", "Start with specific project").action(async (opts) => {
+    const { launchTUI } = await import("./tui-JNZRBEIQ.js");
+    await launchTUI(container, opts.project);
+  });
+  return program;
+}
+
+// src/index.ts
+async function main() {
+  const config = loadConfig();
+  logger.init(config.logDir);
+  initTelemetry(config);
+  const db = createDatabase(config.dbPath);
+  runMigrations(db);
+  const container = createContainer(db);
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    const { launchTUI } = await import("./tui-JNZRBEIQ.js");
+    await launchTUI(container);
+  } else {
+    const program = buildCLI(container);
+    await program.parseAsync(process.argv);
+  }
+  db.close();
+  await shutdownTelemetry();
+}
+main().catch((e) => {
+  const error = e instanceof AppError ? e : new AppError("UNKNOWN", e instanceof Error ? e.message : "Unknown error", e);
+  process.stderr.write(
+    JSON.stringify({ ok: false, error: { code: error.code, message: error.message } }, null, 2) + "\n"
+  );
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map