trekoon 0.3.0 → 0.3.2

package/src/commands/task-readiness.ts

@@ -1,7 +1,7 @@
 import { TrackerDomain } from "../domain/tracker-domain";
 import { type TaskRecord } from "../domain/types";
 
-export const DEFAULT_OPEN_TASK_STATUSES = ["in_progress", "in-progress", "todo"] as const;
+export const DEFAULT_OPEN_TASK_STATUSES = ["in_progress", "todo"] as const;
 export const READY_REASON_READY = "all_dependencies_done";
 export const READY_REASON_BLOCKED = "blocked_by_dependencies";
 
@@ -49,7 +49,7 @@ export interface TaskReadinessResult {
 }
 
 export function taskStatusPriority(status: string): number {
-  if (status === "in_progress" || status === "in-progress") {
+  if (status === "in_progress") {
     return 0;
   }
 
@@ -63,25 +63,13 @@ export function taskStatusPriority(status: string): number {
 export function buildTaskReadiness(domain: TrackerDomain, epicId: string | undefined): TaskReadinessResult {
   const openStatuses = new Set<string>(DEFAULT_OPEN_TASK_STATUSES);
   const openTasks = domain.listTasks(epicId).filter((task) => openStatuses.has(task.status));
+  const taskIds = openTasks.map((task) => task.id);
+  const depMap = domain.batchResolveDependencyStatuses(taskIds);
+
   const assessed = openTasks
     .map((task) => {
-      const blockers: DependencyBlocker[] = [];
-      const dependencies = domain.listDependencies(task.id);
-      for (const dependency of dependencies) {
-        const dependencyStatus =
-          dependency.dependsOnKind === "task"
-            ? domain.getTaskOrThrow(dependency.dependsOnId).status
-            : domain.getSubtaskOrThrow(dependency.dependsOnId).status;
-
-        if (dependencyStatus !== "done") {
-          blockers.push({
-            id: dependency.dependsOnId,
-            kind: dependency.dependsOnKind,
-            status: dependencyStatus,
-          });
-        }
-      }
-
+      const resolved = depMap.get(task.id) ?? { totalDependencies: 0, blockers: [] };
+      const blockers: DependencyBlocker[] = resolved.blockers;
       const blockerCount = blockers.length;
       const readinessReason: ReadyReason = blockerCount === 0 ? READY_REASON_READY : READY_REASON_BLOCKED;
       return {
@@ -91,7 +79,7 @@ export function buildTaskReadiness(domain: TrackerDomain, epicId: string | undef
           reason: readinessReason,
         },
         blockerSummary: {
-          totalDependencies: dependencies.length,
+          totalDependencies: resolved.totalDependencies,
           blockedByCount: blockerCount,
           blockedBy: blockers,
         },

package/src/commands/task.ts

@@ -46,7 +46,7 @@ const SHOW_OPTIONS = ["view", "all"] as const;
 const SEARCH_OPTIONS = ["fields", "preview"] as const;
 const REPLACE_OPTIONS = ["search", "replace", "fields", "preview", "apply"] as const;
 const CREATE_MANY_OPTIONS = ["epic", "e", "task"] as const;
-const UPDATE_OPTIONS = ["all", "ids", "append", "description", "d", "status", "s", "title", "t"] as const;
+const UPDATE_OPTIONS = ["all", "ids", "append", "description", "d", "status", "s", "title", "t", "owner"] as const;
 const STATUS_CASCADE_UPDATE_STATUSES = ["done", "todo"] as const;
 
 function parseIdsOption(rawIds: string | undefined): string[] {
@@ -1071,7 +1071,8 @@ export async function runTask(context: CliContext): Promise<CliResult> {
           readMissingOptionValue(parsed.missingOptionValues, "ids") ??
           readMissingOptionValue(parsed.missingOptionValues, "append") ??
           readMissingOptionValue(parsed.missingOptionValues, "description", "d") ??
-          readMissingOptionValue(parsed.missingOptionValues, "status", "s");
+          readMissingOptionValue(parsed.missingOptionValues, "status", "s") ??
+          readMissingOptionValue(parsed.missingOptionValues, "owner");
         if (missingUpdateOption !== undefined) {
           return failMissingOptionValue("task.update", missingUpdateOption);
         }
@@ -1084,6 +1085,7 @@ export async function runTask(context: CliContext): Promise<CliResult> {
         const description: string | undefined = readOption(parsed.options, "description", "d");
         const append: string | undefined = readOption(parsed.options, "append");
         const status: string | undefined = readOption(parsed.options, "status", "s");
+        const owner: string | undefined = readOption(parsed.options, "owner");
 
         if (updateAll && ids.length > 0) {
           return failResult({
@@ -1210,7 +1212,7 @@ export async function runTask(context: CliContext): Promise<CliResult> {
           append === undefined
             ? description
             : appendLine(domain.getTaskOrThrow(taskId).description, append);
-        const task = mutations.updateTask(taskId, { title, description: nextDescription, status });
+        const task = mutations.updateTask(taskId, { title, description: nextDescription, status, owner });
 
         return okResult({
           command: "task.update",
@@ -1257,10 +1259,50 @@ export async function runTask(context: CliContext): Promise<CliResult> {
           });
         }
 
+        // Check for open subtasks (lenient: warn but allow completion)
+        const openSubtasks = domain.getOpenSubtasks(taskId);
+        const openSubtaskCount = openSubtasks.length;
+        const openSubtaskIds = openSubtasks.map((s) => s.id);
+
+        // Snapshot blocked reverse deps before marking done (lightweight: no full readiness rebuild).
+        // Only direct task-level reverse deps are tracked here; subtask reverse deps are excluded
+        // because subtasks are children within a task, not independent workflow items.
+        const reverseDeps = domain.listReverseDependencies(taskId);
+        const directRevDepTaskIds = reverseDeps
+          .filter((rd) => rd.isDirect && rd.kind === "task")
+          .map((rd) => rd.id);
+        const preDepStatuses = domain.batchResolveDependencyStatuses(directRevDepTaskIds);
+        const preBlockedIds = new Set(
+          directRevDepTaskIds.filter((id) => {
+            const resolved = preDepStatuses.get(id);
+            return resolved !== undefined && resolved.blockers.length > 0;
+          }),
+        );
+
+        // Auto-transition through in_progress when current status is todo or blocked.
+        // Note: this emits two sync events (→in_progress, →done) because each
+        // updateTask call appends its own event.  This is intentional — the status
+        // machine requires the intermediate step, and event consumers should treat
+        // a rapid in_progress→done pair from `task done` as a single logical completion.
+        if (existingTask.status === "todo" || existingTask.status === "blocked") {
+          mutations.updateTask(taskId, { status: "in_progress" });
+        }
+
         const completed = mutations.updateTask(taskId, { status: "done" });
         const readiness = buildTaskReadiness(domain, completed.epicId);
         const nextCandidate = readiness.candidates[0] ?? null;
 
+        // Diff: tasks that were blocked before but are now ready
+        const unblockedTasks = readiness.candidates
+          .filter((item) => preBlockedIds.has(item.task.id))
+          .map((item) => ({
+            id: item.task.id,
+            kind: "task" as const,
+            title: item.task.title,
+            status: item.task.status,
+            wasBlockedBy: [taskId],
+          }));
+
         const nextTree = nextCandidate !== null ? domain.buildTaskTreeDetailed(nextCandidate.task.id) : null;
         const nextDeps = nextCandidate?.blockerSummary.blockedBy ?? [];
 
@@ -1269,7 +1311,17 @@ export async function runTask(context: CliContext): Promise<CliResult> {
           blockedCount: readiness.summary.blockedCount,
         };
 
+        const subtaskWarning = openSubtaskCount > 0
+          ? `Warning: ${openSubtaskCount} subtask(s) still open.`
+          : null;
+
         let human = `Task ${completed.title} marked done.`;
+        if (subtaskWarning !== null) {
+          human += `\n${subtaskWarning}`;
+        }
+        if (unblockedTasks.length > 0) {
+          human += `\nUnblocked: ${unblockedTasks.map((t) => t.title).join(", ")}`;
+        }
         if (nextTree !== null && nextCandidate !== null) {
           human += `\nNext: ${formatTask(nextCandidate.task)}`;
         }
@@ -1280,6 +1332,10 @@ export async function runTask(context: CliContext): Promise<CliResult> {
           human,
           data: {
             completed,
+            openSubtaskCount,
+            openSubtaskIds,
+            warning: subtaskWarning,
+            unblocked: unblockedTasks,
             next: nextTree,
             nextDeps,
             readiness: readinessStats,

package/src/domain/mutation-service.ts

@@ -1,8 +1,9 @@
 import { type Database } from "bun:sqlite";
 
+import { writeTransaction } from "../storage/database";
 import { appendEventWithGitContext } from "../sync/event-writes";
 import { ENTITY_OPERATIONS } from "./mutation-operations";
-import { TrackerDomain } from "./tracker-domain";
+import { TrackerDomain, validateStatusTransition } from "./tracker-domain";
 import {
   type CompactEpicCreateResult,
   type CompactEpicExpandResult,
@@ -104,7 +105,7 @@ export class MutationService {
   }
 
   createEpic(input: { title: string; description: string; status?: string | undefined }): EpicRecord {
-    return this.#db.transaction((): EpicRecord => {
+    return writeTransaction(this.#db, (): EpicRecord => {
       const epic = this.#domain.createEpic(input);
       this.#appendEntityEvent("epic", epic.id, ENTITY_OPERATIONS.epic.created, {
         title: epic.title,
@@ -112,7 +113,7 @@ export class MutationService {
         status: epic.status,
       });
       return epic;
-    })();
+    });
   }
 
   createEpicGraph(input: {
@@ -123,7 +124,7 @@ export class MutationService {
     subtaskSpecs: readonly CompactSubtaskSpec[];
     dependencySpecs: readonly CompactDependencySpec[];
   }): CompactEpicCreateResult {
-    return this.#db.transaction((): CompactEpicCreateResult => {
+    return writeTransaction(this.#db, (): CompactEpicCreateResult => {
       const epic = this.#domain.createEpic(input);
       const created = this.#domain.expandEpic({
         epicId: epic.id,
@@ -172,14 +173,18 @@ export class MutationService {
         dependencies: created.dependencies,
         result: created.result,
       };
-    })();
+    });
   }
 
   updateEpic(
     id: string,
     input: { title?: string | undefined; description?: string | undefined; status?: string | undefined },
   ): EpicRecord {
-    return this.#db.transaction((): EpicRecord => {
+    return writeTransaction(this.#db, (): EpicRecord => {
+      if (input.status !== undefined) {
+        const existing = this.#domain.getEpicOrThrow(id);
+        validateStatusTransition(existing.status, input.status, "epic", id);
+      }
       const epic = this.#domain.updateEpic(id, input);
       this.#appendEntityEvent("epic", epic.id, ENTITY_OPERATIONS.epic.updated, {
         title: epic.title,
@@ -187,27 +192,27 @@ export class MutationService {
         status: epic.status,
       });
       return epic;
-    })();
+    });
   }
 
   updateEpicStatusCascade(id: string, status: string): StatusCascadePlan {
-    return this.#db.transaction((): StatusCascadePlan => {
+    return writeTransaction(this.#db, (): StatusCascadePlan => {
       const plan = this.#domain.planStatusCascade("epic", id, status);
       this.#assertCascadeNotBlocked(plan);
       this.#applyStatusCascadePlan(plan);
       return plan;
-    })();
+    });
   }
 
   deleteEpic(id: string): void {
-    this.#db.transaction((): void => {
+    writeTransaction(this.#db, (): void => {
       this.#domain.deleteEpic(id);
       this.#appendEntityEvent("epic", id, ENTITY_OPERATIONS.epic.deleted, {});
-    })();
+    });
   }
 
   createTask(input: { epicId: string; title: string; description: string; status?: string | undefined }): TaskRecord {
-    return this.#db.transaction((): TaskRecord => {
+    return writeTransaction(this.#db, (): TaskRecord => {
       const task = this.#domain.createTask(input);
       this.#appendEntityEvent("task", task.id, ENTITY_OPERATIONS.task.created, {
         epic_id: task.epicId,
@@ -216,11 +221,11 @@ export class MutationService {
         status: task.status,
       });
       return task;
-    })();
+    });
   }
 
   createTaskBatch(input: { epicId: string; specs: readonly CompactTaskSpec[] }): CompactTaskBatchCreateResult {
-    return this.#db.transaction((): CompactTaskBatchCreateResult => {
+    return writeTransaction(this.#db, (): CompactTaskBatchCreateResult => {
       const created = this.#domain.createTaskBatch(input);
       for (const task of created.tasks) {
         this.#appendEntityEvent("task", task.id, ENTITY_OPERATIONS.task.created, {
@@ -231,7 +236,7 @@ export class MutationService {
         });
       }
       return created;
-    })();
+    });
   }
 
   expandEpic(input: {
@@ -240,7 +245,7 @@ export class MutationService {
     subtaskSpecs: readonly CompactSubtaskSpec[];
     dependencySpecs: readonly CompactDependencySpec[];
   }): CompactEpicExpandResult {
-    return this.#db.transaction((): CompactEpicExpandResult => {
+    return writeTransaction(this.#db, (): CompactEpicExpandResult => {
       const created = this.#domain.expandEpic(input);
       for (const task of created.tasks) {
         this.#appendEntityEvent("task", task.id, ENTITY_OPERATIONS.task.created, {
@@ -270,39 +275,44 @@ export class MutationService {
       }
 
       return created;
-    })();
+    });
   }
 
   updateTask(
     id: string,
-    input: { title?: string | undefined; description?: string | undefined; status?: string | undefined },
+    input: { title?: string | undefined; description?: string | undefined; status?: string | undefined; owner?: string | null | undefined },
   ): TaskRecord {
-    return this.#db.transaction((): TaskRecord => {
+    return writeTransaction(this.#db, (): TaskRecord => {
+      if (input.status !== undefined) {
+        const existing = this.#domain.getTaskOrThrow(id);
+        validateStatusTransition(existing.status, input.status, "task", id);
+      }
       const task = this.#domain.updateTask(id, input);
       this.#appendEntityEvent("task", task.id, ENTITY_OPERATIONS.task.updated, {
         epic_id: task.epicId,
         title: task.title,
         description: task.description,
         status: task.status,
+        owner: task.owner,
       });
       return task;
-    })();
+    });
   }
 
   updateTaskStatusCascade(id: string, status: string): StatusCascadePlan {
-    return this.#db.transaction((): StatusCascadePlan => {
+    return writeTransaction(this.#db, (): StatusCascadePlan => {
       const plan = this.#domain.planStatusCascade("task", id, status);
       this.#assertCascadeNotBlocked(plan);
       this.#applyStatusCascadePlan(plan);
       return plan;
-    })();
+    });
   }
 
   deleteTask(id: string): void {
-    this.#db.transaction((): void => {
+    writeTransaction(this.#db, (): void => {
       this.#domain.deleteTask(id);
       this.#appendEntityEvent("task", id, ENTITY_OPERATIONS.task.deleted, {});
-    })();
+    });
   }
 
   createSubtask(input: {
@@ -311,7 +321,7 @@ export class MutationService {
     description?: string | undefined;
     status?: string | undefined;
   }): SubtaskRecord {
-    return this.#db.transaction((): SubtaskRecord => {
+    return writeTransaction(this.#db, (): SubtaskRecord => {
       const subtask = this.#domain.createSubtask(input);
       this.#appendEntityEvent("subtask", subtask.id, ENTITY_OPERATIONS.subtask.created, {
         task_id: subtask.taskId,
@@ -320,11 +330,11 @@ export class MutationService {
         status: subtask.status,
       });
       return subtask;
-    })();
+    });
   }
 
   createSubtaskBatch(input: { taskId: string; specs: readonly CompactSubtaskSpec[] }): CompactSubtaskBatchCreateResult {
-    return this.#db.transaction((): CompactSubtaskBatchCreateResult => {
+    return writeTransaction(this.#db, (): CompactSubtaskBatchCreateResult => {
       const created = this.#domain.createSubtaskBatch(input);
       for (const subtask of created.subtasks) {
         this.#appendEntityEvent("subtask", subtask.id, ENTITY_OPERATIONS.subtask.created, {
@@ -335,34 +345,39 @@ export class MutationService {
         });
       }
       return created;
-    })();
+    });
   }
 
   updateSubtask(
     id: string,
-    input: { title?: string | undefined; description?: string | undefined; status?: string | undefined },
+    input: { title?: string | undefined; description?: string | undefined; status?: string | undefined; owner?: string | null | undefined },
   ): SubtaskRecord {
-    return this.#db.transaction((): SubtaskRecord => {
+    return writeTransaction(this.#db, (): SubtaskRecord => {
+      if (input.status !== undefined) {
+        const existing = this.#domain.getSubtaskOrThrow(id);
+        validateStatusTransition(existing.status, input.status, "subtask", id);
+      }
       const subtask = this.#domain.updateSubtask(id, input);
       this.#appendEntityEvent("subtask", subtask.id, ENTITY_OPERATIONS.subtask.updated, {
         task_id: subtask.taskId,
         title: subtask.title,
         description: subtask.description,
         status: subtask.status,
+        owner: subtask.owner,
       });
       return subtask;
-    })();
+    });
   }
 
   deleteSubtask(id: string): void {
-    this.#db.transaction((): void => {
+    writeTransaction(this.#db, (): void => {
       this.#domain.deleteSubtask(id);
       this.#appendEntityEvent("subtask", id, ENTITY_OPERATIONS.subtask.deleted, {});
-    })();
+    });
   }
 
   addDependency(sourceId: string, dependsOnId: string): DependencyRecord {
-    return this.#db.transaction((): DependencyRecord => {
+    return writeTransaction(this.#db, (): DependencyRecord => {
       const dependency = this.#domain.addDependency(sourceId, dependsOnId);
       this.#appendEntityEvent("dependency", dependency.id, ENTITY_OPERATIONS.dependency.added, {
         source_id: dependency.sourceId,
@@ -371,11 +386,11 @@ export class MutationService {
         depends_on_kind: dependency.dependsOnKind,
       });
       return dependency;
-    })();
+    });
   }
 
   addDependencyBatch(input: { specs: readonly CompactDependencySpec[] }): CompactDependencyBatchAddResult {
-    return this.#db.transaction((): CompactDependencyBatchAddResult => {
+    return writeTransaction(this.#db, (): CompactDependencyBatchAddResult => {
       const created = this.#domain.addDependencyBatch(input);
       for (const dependency of created.dependencies) {
         this.#appendEntityEvent("dependency", dependency.id, ENTITY_OPERATIONS.dependency.added, {
@@ -386,11 +401,11 @@ export class MutationService {
         });
       }
       return created;
-    })();
+    });
   }
 
   removeDependency(sourceId: string, dependsOnId: string): number {
-    return this.#db.transaction((): number => {
+    return writeTransaction(this.#db, (): number => {
       const removed = this.#domain.removeDependency(sourceId, dependsOnId);
       if (removed > 0) {
         this.#appendEntityEvent("dependency", `${sourceId}->${dependsOnId}`, ENTITY_OPERATIONS.dependency.removed, {
@@ -399,11 +414,19 @@ export class MutationService {
         });
       }
       return removed;
-    })();
+    });
   }
 
   describeError(error: unknown): string | undefined {
-    if (!(error instanceof DomainError) || error.code !== "dependency_blocked") {
+    if (!(error instanceof DomainError)) {
+      return undefined;
+    }
+
+    if (error.code === "status_transition_invalid") {
+      return error.message;
+    }
+
+    if (error.code !== "dependency_blocked") {
       return undefined;
     }
 
@@ -560,6 +583,7 @@ export class MutationService {
           title: task.title,
           description: task.description,
           status: task.status,
+          owner: task.owner,
         });
         continue;
       }
@@ -570,6 +594,7 @@ export class MutationService {
         title: subtask.title,
         description: subtask.description,
         status: subtask.status,
+        owner: subtask.owner,
       });
     }
   }
@@ -582,7 +607,7 @@ export class MutationService {
   ): ScopeReplacementResult {
     const result = this.#buildScopeReplacementResult(nodes, searchText, replacementText, fields, "apply");
 
-    this.#db.transaction((): void => {
+    writeTransaction(this.#db, (): void => {
       for (const node of nodes) {
         const nextTitle = fields.includes("title") ? replaceMatches(node.title, searchText, replacementText) : node.title;
         const nextDescription = fields.includes("description")
@@ -610,6 +635,7 @@ export class MutationService {
             title: task.title,
             description: task.description,
             status: task.status,
+            owner: task.owner,
           });
           continue;
         }
@@ -620,9 +646,10 @@ export class MutationService {
           title: subtask.title,
           description: subtask.description,
           status: subtask.status,
+          owner: subtask.owner,
         });
       }
-    })();
+    });
 
     return result;
   }