schub 0.1.2 → 0.1.4

package/src/features/tasks/filesystem.test.ts

@@ -1,8 +1,15 @@
 import { expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { listTasks, loadTaskDependencies } from "./filesystem";
+import type { TaskStatus } from "./constants";
+import {
+  archiveTasksForChange,
+  listTasks,
+  listTasksForChange,
+  loadTaskDependencies,
+  updateTaskStatuses,
+} from "./filesystem";
 
 const setupChecklistRepo = () => {
   const base = mkdtempSync(join(tmpdir(), "schub-checklist-"));
@@ -12,24 +19,131 @@ const setupChecklistRepo = () => {
 
   const tasks = [
     {
-      id: "T001",
+      id: "T0001",
       slug: "unchecked-only",
-      body: `# Task: T001 Unchecked Only\n\n## Steps\n- [ ] First item\n- [ ] Second item\n`,
+      body: `# Task: T0001 Unchecked Only\n\n## Steps\n- [ ] First item\n- [ ] Second item\n`,
     },
     {
-      id: "T002",
+      id: "T0002",
       slug: "checked-only",
-      body: `# Task: T002 Checked Only\n\n## Steps\n- [x] Finished item\n`,
+      body: `# Task: T0002 Checked Only\n\n## Steps\n- [x] Finished item\n`,
     },
     {
-      id: "T003",
+      id: "T0003",
       slug: "mixed-checklist",
-      body: `# Task: T003 Mixed Checklist\n\n## Steps\n- [ ] Remaining item\n- [x] Done item\n\n## Acceptance\n- [ ] Ignore this\n`,
+      body: `# Task: T0003 Mixed Checklist\n\n## Steps\n- [ ] Remaining item\n- [x] Done item\n\n## Acceptance\n- [ ] Ignore this\n`,
     },
     {
-      id: "T004",
+      id: "T0004",
       slug: "missing-checklist",
-      body: `# Task: T004 Missing Checklist\n\n## Steps\n- Do the thing\n- Another item\n\n## Acceptance\n- [ ] Ignore this too\n`,
+      body: `# Task: T0004 Missing Checklist\n\n## Steps\n- Do the thing\n- Another item\n\n## Acceptance\n- [ ] Ignore this too\n`,
+    },
+  ];
+
+  for (const task of tasks) {
+    const filePath = join(tasksRoot, `${task.id}_${task.slug}.md`);
+    writeFileSync(filePath, task.body, "utf8");
+  }
+
+  return schubDir;
+};
+
+const setupArchiveRepo = () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-archive-"));
+  const schubDir = join(base, ".schub");
+  const tasksRoot = join(schubDir, "tasks");
+  const statuses = ["backlog", "wip", "done"];
+
+  for (const status of statuses) {
+    mkdirSync(join(tasksRoot, status), { recursive: true });
+  }
+
+  const changeId = "C0001_archive-change";
+  writeFileSync(
+    join(tasksRoot, "backlog", "T0010_backlog-task.md"),
+    `---\nchange_id: ${changeId}\n---\n# Task: T0010 Backlog Task\n`,
+    "utf8",
+  );
+  writeFileSync(
+    join(tasksRoot, "wip", "T0011_wip-task.md"),
+    `---\nchange_id: ${changeId}\n---\n# Task: T0011 Wip Task\n`,
+    "utf8",
+  );
+  writeFileSync(
+    join(tasksRoot, "done", "T0012_other-task.md"),
+    "---\nchange_id: C0002_other-change\n---\n# Task: T0012 Other Task\n",
+    "utf8",
+  );
+
+  return { schubDir, tasksRoot, changeId };
+};
+
+const setupChangeFilterRepo = () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-change-filter-"));
+  const schubDir = join(base, ".schub");
+  const tasksRoot = join(schubDir, "tasks");
+  const statuses = ["backlog", "ready", "wip", "blocked", "done", "archived"];
+
+  for (const status of statuses) {
+    mkdirSync(join(tasksRoot, status), { recursive: true });
+  }
+
+  const changeId = "C0200_filter-change";
+  const otherChangeId = "C0201_other-change";
+  const tasks = [
+    { id: "T0200", status: "backlog", slug: "backlog-task", changeId },
+    { id: "T0201", status: "wip", slug: "wip-task", changeId },
+    { id: "T0202", status: "done", slug: "done-task", changeId: otherChangeId },
+    { id: "T0203", status: "blocked", slug: "blocked-task", changeId },
+    { id: "T0204", status: "ready", slug: "ready-task" },
+    { id: "T0205", status: "archived", slug: "archived-task", changeId },
+  ];
+
+  for (const task of tasks) {
+    const frontmatter = task.changeId ? `---\nchange_id: ${task.changeId}\n---\n` : "";
+    const title = task.slug.replace(/-/g, " ");
+    const body = `${frontmatter}# Task: ${task.id} ${title}\n`;
+    const filePath = join(tasksRoot, task.status, `${task.id}_${task.slug}.md`);
+    writeFileSync(filePath, body, "utf8");
+  }
+
+  return { schubDir, changeId };
+};
+
+const setupBacklogUpdateRepo = () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-backlog-update-"));
+  const schubDir = join(base, ".schub");
+  const tasksRoot = join(schubDir, "tasks");
+  const backlogRoot = join(tasksRoot, "backlog");
+  mkdirSync(backlogRoot, { recursive: true });
+
+  writeFileSync(join(backlogRoot, "T0100_ready-task.md"), "# Task: T0100 Ready Task\n", "utf8");
+  writeFileSync(join(backlogRoot, "T0101_archive-task.md"), "# Task: T0101 Archive Task\n", "utf8");
+
+  return { schubDir, tasksRoot };
+};
+
+const setupBlockedReasonRepo = () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-blocked-reason-"));
+  const schubDir = join(base, ".schub");
+  const tasksRoot = join(schubDir, "tasks", "blocked");
+  mkdirSync(tasksRoot, { recursive: true });
+
+  const tasks = [
+    {
+      id: "T0020",
+      slug: "blocked-with-reason",
+      body: "---\nblocked_reason: Waiting on API\n---\n# Task: T0020 Blocked With Reason\n",
+    },
+    {
+      id: "T0021",
+      slug: "blocked-with-reason-two",
+      body: "---\nblocked_reason: Vendor response\n---\n# Task: T0021 Blocked Reason Two\n",
+    },
+    {
+      id: "T0022",
+      slug: "blocked-without-reason",
+      body: "# Task: T0022 Blocked Without Reason\n",
     },
   ];
 
@@ -49,10 +163,10 @@ test("listTasks includes Steps-only checklist counts", () => {
   const schubDir = setupChecklistRepo();
   const tasks = listTasks(schubDir);
 
-  const unchecked = getTaskById(tasks, "T001");
-  const checked = getTaskById(tasks, "T002");
-  const mixed = getTaskById(tasks, "T003");
-  const missing = getTaskById(tasks, "T004");
+  const unchecked = getTaskById(tasks, "T0001");
+  const checked = getTaskById(tasks, "T0002");
+  const mixed = getTaskById(tasks, "T0003");
+  const missing = getTaskById(tasks, "T0004");
 
   expect(unchecked).toMatchObject({ checklistTotal: 2, checklistRemaining: 2 });
   expect(checked).toMatchObject({ checklistTotal: 1, checklistRemaining: 0 });
@@ -65,10 +179,10 @@ test("loadTaskDependencies includes Steps-only checklist counts", () => {
   const schubDir = setupChecklistRepo();
   const tasks = loadTaskDependencies(schubDir);
 
-  const unchecked = getTaskById(tasks, "T001");
-  const checked = getTaskById(tasks, "T002");
-  const mixed = getTaskById(tasks, "T003");
-  const missing = getTaskById(tasks, "T004");
+  const unchecked = getTaskById(tasks, "T0001");
+  const checked = getTaskById(tasks, "T0002");
+  const mixed = getTaskById(tasks, "T0003");
+  const missing = getTaskById(tasks, "T0004");
 
   expect(unchecked).toMatchObject({ checklistTotal: 2, checklistRemaining: 2 });
   expect(checked).toMatchObject({ checklistTotal: 1, checklistRemaining: 0 });
@@ -76,3 +190,156 @@ test("loadTaskDependencies includes Steps-only checklist counts", () => {
   expect(missing?.checklistTotal).toBeUndefined();
   expect(missing?.checklistRemaining).toBeUndefined();
 });
+
+test("listTasks includes blocked reasons when present", () => {
+  const schubDir = setupBlockedReasonRepo();
+  const tasks = listTasks(schubDir);
+
+  const blocked = getTaskById(tasks, "T0020");
+  const uppercase = getTaskById(tasks, "T0021");
+  const missing = getTaskById(tasks, "T0022");
+
+  expect(blocked?.blockedReason).toBe("Waiting on API");
+  expect(uppercase?.blockedReason).toBe("Vendor response");
+  expect(missing?.blockedReason).toBeUndefined();
+});
+
+test("listTasks accepts variable-length task ids", () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-variable-tasks-"));
+  const schubDir = join(base, ".schub");
+  const tasksRoot = join(schubDir, "tasks", "backlog");
+  mkdirSync(tasksRoot, { recursive: true });
+
+  writeFileSync(join(tasksRoot, "T1_short-task.md"), "# Task: T1 Short Task\n", "utf8");
+  writeFileSync(join(tasksRoot, "T12345_long-task.md"), "# Task: T12345 Long Task\n", "utf8");
+
+  const tasks = listTasks(schubDir, ["backlog"]);
+
+  expect(tasks.map((task) => task.id)).toEqual(["T1", "T12345"]);
+});
+
+test("loadTaskDependencies includes blocked reasons when present", () => {
+  const schubDir = setupBlockedReasonRepo();
+  const tasks = loadTaskDependencies(schubDir);
+
+  const blocked = getTaskById(tasks, "T0020");
+  const uppercase = getTaskById(tasks, "T0021");
+  const missing = getTaskById(tasks, "T0022");
+
+  expect(blocked?.blockedReason).toBe("Waiting on API");
+  expect(uppercase?.blockedReason).toBe("Vendor response");
+  expect(missing?.blockedReason).toBeUndefined();
+});
+
+test("loadTaskDependencies captures variable-length dependencies", () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-variable-deps-"));
+  const schubDir = join(base, ".schub");
+  const tasksRoot = join(schubDir, "tasks", "backlog");
+  mkdirSync(tasksRoot, { recursive: true });
+
+  writeFileSync(
+    join(tasksRoot, "T1_primary-task.md"),
+    "---\ndepends_on:\n  - T7\n  - T12345\n---\n# Task: T1 Primary Task\n",
+    "utf8",
+  );
+  writeFileSync(join(tasksRoot, "T7_support-task.md"), "# Task: T7 Support Task\n", "utf8");
+  writeFileSync(join(tasksRoot, "T12345_support-task.md"), "# Task: T12345 Support Task\n", "utf8");
+
+  const tasks = loadTaskDependencies(schubDir, ["backlog"]);
+  const primary = getTaskById(tasks, "T1");
+
+  expect(primary?.dependsOn).toEqual(["T7", "T12345"]);
+});
+
+test("listTasksForChange filters tasks across statuses", () => {
+  const { schubDir, changeId } = setupChangeFilterRepo();
+  const tasks = listTasksForChange(schubDir, changeId);
+
+  expect(tasks.map((task) => task.id)).toEqual(["T0200", "T0201", "T0203", "T0205"]);
+  expect(getTaskById(tasks, "T0202")).toBeUndefined();
+  expect(getTaskById(tasks, "T0204")).toBeUndefined();
+
+  const expectations = new Map<string, { status: TaskStatus; title: string }>([
+    ["T0200", { status: "backlog", title: "backlog task" }],
+    ["T0201", { status: "wip", title: "wip task" }],
+    ["T0203", { status: "blocked", title: "blocked task" }],
+    ["T0205", { status: "archived", title: "archived task" }],
+  ]);
+
+  for (const task of tasks) {
+    const expected = expectations.get(task.id);
+    expect(expected).toBeDefined();
+    expect(task.changeId).toBe(changeId);
+    expect(task.path).toContain(`.schub/tasks/${task.status}/`);
+    if (expected) {
+      expect(task.status).toBe(expected.status);
+      expect(task.title).toBe(expected.title);
+    }
+  }
+});
+
+test("archiveTasksForChange moves matching tasks to archived", () => {
+  const { schubDir, tasksRoot, changeId } = setupArchiveRepo();
+  const archived = archiveTasksForChange(schubDir, changeId);
+
+  const archiveRoot = join(tasksRoot, "archived");
+  const backlogTask = join(archiveRoot, "T0010_backlog-task.md");
+  const wipTask = join(archiveRoot, "T0011_wip-task.md");
+
+  expect(existsSync(archiveRoot)).toBe(true);
+  expect(existsSync(backlogTask)).toBe(true);
+  expect(existsSync(wipTask)).toBe(true);
+  expect(existsSync(join(tasksRoot, "backlog", "T0010_backlog-task.md"))).toBe(false);
+  expect(existsSync(join(tasksRoot, "wip", "T0011_wip-task.md"))).toBe(false);
+  expect(existsSync(join(tasksRoot, "done", "T0012_other-task.md"))).toBe(true);
+
+  expect(archived.map((task) => task.id)).toEqual(["T0010", "T0011"]);
+  expect(archived.every((task) => task.status === "archived")).toBe(true);
+  expect(archived[0]?.path).toContain(".schub/tasks/archived/");
+});
+
+test("updateTaskStatuses moves backlog task to ready", () => {
+  const { schubDir, tasksRoot } = setupBacklogUpdateRepo();
+  const updated = updateTaskStatuses(schubDir, ["T0100"], "ready");
+
+  const readyRoot = join(tasksRoot, "ready");
+  const readyTask = join(readyRoot, "T0100_ready-task.md");
+
+  expect(existsSync(readyRoot)).toBe(true);
+  expect(existsSync(readyTask)).toBe(true);
+  expect(existsSync(join(tasksRoot, "backlog", "T0100_ready-task.md"))).toBe(false);
+  expect(updated).toMatchObject([{ id: "T0100", status: "ready" }]);
+  expect(updated[0]?.path).toContain(".schub/tasks/ready/");
+});
+
+test("updateTaskStatuses moves backlog task to archived", () => {
+  const { schubDir, tasksRoot } = setupBacklogUpdateRepo();
+  const updated = updateTaskStatuses(schubDir, ["T0101"], "archived");
+
+  const archivedRoot = join(tasksRoot, "archived");
+  const archivedTask = join(archivedRoot, "T0101_archive-task.md");
+
+  expect(existsSync(archivedRoot)).toBe(true);
+  expect(existsSync(archivedTask)).toBe(true);
+  expect(existsSync(join(tasksRoot, "backlog", "T0101_archive-task.md"))).toBe(false);
+  expect(updated).toMatchObject([{ id: "T0101", status: "archived" }]);
+  expect(updated[0]?.path).toContain(".schub/tasks/archived/");
+});
+
+test("updateTaskStatuses moves ready task to backlog", () => {
+  const { schubDir, tasksRoot } = setupBacklogUpdateRepo();
+  const readyRoot = join(tasksRoot, "ready");
+  const backlogRoot = join(tasksRoot, "backlog");
+  const readyTask = join(readyRoot, "T0102_ready-task.md");
+  const backlogTask = join(backlogRoot, "T0102_ready-task.md");
+
+  mkdirSync(readyRoot, { recursive: true });
+  writeFileSync(readyTask, "# Task: T0102 Ready Task\n", "utf8");
+
+  const updated = updateTaskStatuses(schubDir, ["T0102"], "backlog");
+
+  expect(existsSync(backlogTask)).toBe(true);
+  expect(existsSync(readyTask)).toBe(false);
+  expect(updated).toMatchObject([{ id: "T0102", status: "backlog" }]);
+  expect(updated[0]?.path).toContain(".schub/tasks/backlog/");
+});

package/src/features/tasks/filesystem.ts

@@ -1,5 +1,6 @@
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { readFrontmatter } from "../../frontmatter";
 import { TASK_STATUSES, type TaskDependency, type TaskInfo, type TaskStatus } from "./constants";
 import { compareTaskIds, compareTasks } from "./sorting";
 
@@ -40,6 +41,9 @@ const parseTaskFilename = (fileName: string): { id: string; title: string } | nu
   }
 
   const id = baseName.slice(0, underscoreIndex);
+  if (!/^T\d+$/.test(id)) {
+    return null;
+  }
   const titleSlug = baseName.slice(underscoreIndex + 1);
   return { id, title: titleSlug.replace(/-/g, " ") };
 };
@@ -51,6 +55,7 @@ type ParsedTaskFile = {
   changeId?: string;
   checklistRemaining?: number;
   checklistTotal?: number;
+  blockedReason?: string;
 };
 
 const parseChecklistCounts = (content: string) => {
@@ -104,21 +109,21 @@ const parseTaskFile = (filePath: string, fallback: { id: string; title: string }
     return { ...fallback, dependsOn: [] };
   }
 
-  const changeIdMatch = content.match(/^\*\*Change ID\*\*:\s*\[?`?([^\]`]+)`?]?/m);
-  const changeId = changeIdMatch?.[1]?.trim();
+  const { data } = readFrontmatter(content);
+  const changeIdValue = data.change_id;
+  const changeId = typeof changeIdValue === "string" ? changeIdValue.trim() : undefined;
 
-  const dependsMatch = content.match(/^\*\*Depends on\*\*:\s*(.+)$/m);
+  const dependsValue = data.depends_on;
   let dependsOn: string[] = [];
-  if (dependsMatch) {
-    const raw = dependsMatch[1].trim();
-    if (!/^none$/i.test(raw)) {
-      const matches = raw.match(/\bT\d+\b/g);
-      if (matches) {
-        dependsOn = Array.from(new Set(matches));
-      }
-    }
+  if (Array.isArray(dependsValue)) {
+    dependsOn = dependsValue.map((value) => value.trim()).filter(Boolean);
+  } else if (typeof dependsValue === "string" && dependsValue.trim()) {
+    dependsOn = [dependsValue.trim()];
   }
 
+  const blockedReasonValue = data.blocked_reason;
+  const blockedReason =
+    typeof blockedReasonValue === "string" && blockedReasonValue.trim() ? blockedReasonValue.trim() : undefined;
   const checklistCounts = parseChecklistCounts(content);
 
   return {
@@ -126,11 +131,19 @@ const parseTaskFile = (filePath: string, fallback: { id: string; title: string }
     title: fallback.title,
     dependsOn,
     changeId,
+    blockedReason: blockedReason || undefined,
     ...(checklistCounts ?? {}),
   };
 };
+type TaskFileEntry = {
+  id: string;
+  title: string;
+  status: TaskStatus;
+  path: string;
+  parsedFile: ParsedTaskFile;
+};
 
-export const listTasks = (schubDir: string, statuses: readonly TaskStatus[] = TASK_STATUSES): TaskInfo[] => {
+const loadTaskFiles = (schubDir: string, statuses: readonly TaskStatus[] = TASK_STATUSES) => {
   const tasksRoot = join(schubDir, "tasks");
   if (!existsSync(tasksRoot) || !isDirectory(tasksRoot)) {
     return [];
@@ -138,7 +151,7 @@ export const listTasks = (schubDir: string, statuses: readonly TaskStatus[] = TA
 
   const allowed = new Set(statuses);
   const repoRoot = dirname(schubDir);
-  const tasks: TaskInfo[] = [];
+  const tasks: TaskFileEntry[] = [];
 
   for (const status of TASK_STATUSES) {
     if (!allowed.has(status)) {
@@ -168,12 +181,24 @@ export const listTasks = (schubDir: string, statuses: readonly TaskStatus[] = TA
         title: parsed.title,
         status,
         path: relative(repoRoot, filePath),
-        checklistRemaining: parsedFile.checklistRemaining,
-        checklistTotal: parsedFile.checklistTotal,
+        parsedFile,
       });
     }
   }
 
+  return tasks;
+};
+export const listTasks = (schubDir: string, statuses: readonly TaskStatus[] = TASK_STATUSES): TaskInfo[] => {
+  const tasks = loadTaskFiles(schubDir, statuses).map((task) => ({
+    id: task.id,
+    title: task.title,
+    status: task.status,
+    path: task.path,
+    checklistRemaining: task.parsedFile.checklistRemaining,
+    checklistTotal: task.parsedFile.checklistTotal,
+    blockedReason: task.parsedFile.blockedReason,
+  }));
+
   return tasks.sort(compareTasks);
 };
 
@@ -181,20 +206,86 @@ export const loadTaskDependencies = (
   schubDir: string,
   statuses: readonly TaskStatus[] = TASK_STATUSES,
 ): TaskDependency[] => {
+  const tasks = loadTaskFiles(schubDir, statuses).map((task) => {
+    const dependsOn = task.parsedFile.dependsOn.sort(compareTaskIds);
+
+    return {
+      id: task.id,
+      title: task.title,
+      status: task.status,
+      path: task.path,
+      dependsOn,
+      changeId: task.parsedFile.changeId,
+      checklistRemaining: task.parsedFile.checklistRemaining,
+      checklistTotal: task.parsedFile.checklistTotal,
+      blockedReason: task.parsedFile.blockedReason,
+    };
+  });
+
+  return tasks.sort(compareTasks);
+};
+
+export const listTasksForChange = (
+  schubDir: string,
+  changeId: string,
+  statuses: readonly TaskStatus[] = TASK_STATUSES,
+) => {
+  const normalizedChangeId = changeId.trim();
+  const tasks = loadTaskFiles(schubDir, statuses)
+    .filter((task) => task.parsedFile.changeId === normalizedChangeId)
+    .map((task) => ({
+      id: task.id,
+      title: task.title,
+      status: task.status,
+      path: task.path,
+      changeId: task.parsedFile.changeId,
+    }));
+
+  return tasks.sort(compareTasks);
+};
+
+type TaskUpdateStatus = "backlog" | "ready" | "archived";
+
+export const updateTaskStatuses = (schubDir: string, taskIds: string[], status: TaskUpdateStatus): TaskInfo[] => {
   const tasksRoot = join(schubDir, "tasks");
-  if (!existsSync(tasksRoot) || !isDirectory(tasksRoot)) {
-    return [];
-  }
+  const targetRoot = join(tasksRoot, status);
+  mkdirSync(targetRoot, { recursive: true });
 
-  const allowed = new Set(statuses);
   const repoRoot = dirname(schubDir);
-  const tasks: TaskDependency[] = [];
+  const sourceTasks = listTasks(schubDir, ["backlog", "ready"]);
+  const tasksById = new Map(sourceTasks.map((task) => [task.id, task]));
+
+  return taskIds
+    .map((taskId) => tasksById.get(taskId))
+    .filter((task): task is TaskInfo => Boolean(task))
+    .map((task) => {
+      const currentPath = join(repoRoot, task.path);
+      const nextPath = join(targetRoot, basename(task.path));
+      renameSync(currentPath, nextPath);
+
+      return {
+        ...task,
+        status,
+        path: relative(repoRoot, nextPath),
+      };
+    });
+};
 
-  for (const status of TASK_STATUSES) {
-    if (!allowed.has(status)) {
-      continue;
-    }
+const ACTIVE_TASK_STATUSES = TASK_STATUSES.filter((status) => status !== "archived");
 
+export const assignTaskToWip = (schubDir: string, taskId: string): TaskInfo => {
+  const normalizedId = taskId.trim().toUpperCase();
+  if (!normalizedId) {
+    throw new Error("Provide --id.");
+  }
+
+  const tasksRoot = join(schubDir, "tasks");
+  const targetRoot = join(tasksRoot, "wip");
+  mkdirSync(targetRoot, { recursive: true });
+
+  const repoRoot = dirname(schubDir);
+
+  for (const status of ACTIVE_TASK_STATUSES) {
     const statusDir = join(tasksRoot, status);
     if (!existsSync(statusDir) || !isDirectory(statusDir)) {
       continue;
@@ -207,26 +298,48 @@ export const loadTaskDependencies = (
       }
 
       const parsed = parseTaskFilename(entry.name);
-      if (!parsed) {
+      if (!parsed || parsed.id !== normalizedId) {
         continue;
       }
 
-      const filePath = join(statusDir, entry.name);
-      const parsedFile = parseTaskFile(filePath, parsed);
-      const dependsOn = parsedFile.dependsOn.sort(compareTaskIds);
+      const currentPath = join(statusDir, entry.name);
+      const nextPath = join(targetRoot, entry.name);
+      if (currentPath !== nextPath) {
+        renameSync(currentPath, nextPath);
+      }
 
-      tasks.push({
+      return {
         id: parsed.id,
         title: parsed.title,
-        status,
-        path: relative(repoRoot, filePath),
-        dependsOn,
-        changeId: parsedFile.changeId,
-        checklistRemaining: parsedFile.checklistRemaining,
-        checklistTotal: parsedFile.checklistTotal,
-      });
+        status: "wip",
+        path: relative(repoRoot, nextPath),
+      };
     }
   }
 
-  return tasks.sort(compareTasks);
+  throw new Error(`Task ${normalizedId} not found.`);
+};
+
+export const archiveTasksForChange = (schubDir: string, changeId: string) => {
+  const normalizedChangeId = changeId.trim();
+  const tasksRoot = join(schubDir, "tasks");
+  const archiveRoot = join(tasksRoot, "archived");
+  mkdirSync(archiveRoot, { recursive: true });
+
+  const repoRoot = dirname(schubDir);
+  const tasks = loadTaskDependencies(schubDir, ACTIVE_TASK_STATUSES).filter(
+    (task) => task.changeId === normalizedChangeId,
+  );
+
+  return tasks.map((task) => {
+    const currentPath = join(repoRoot, task.path);
+    const archivePath = join(archiveRoot, basename(task.path));
+    renameSync(currentPath, archivePath);
+
+    return {
+      ...task,
+      status: "archived",
+      path: relative(repoRoot, archivePath),
+    };
+  });
 };

package/src/features/tasks/graph.ts

@@ -1,5 +1,20 @@
 import type { TaskDependency, TaskGraph, TaskGraphLine, TaskGraphNode } from "./constants";
-import { compareTaskIds, compareTasks } from "./sorting";
+import { compareTaskIds } from "./sorting";
+
+const compareText = (left: string, right: string) => left.localeCompare(right, undefined, { sensitivity: "base" });
+
+const taskSortTitle = (task: TaskGraphNode) => {
+  const title = trimTaskTitle(task.title);
+  return title || task.id;
+};
+
+const compareTaskTitles = (left: TaskGraphNode, right: TaskGraphNode) => {
+  const titleCompare = compareText(taskSortTitle(left), taskSortTitle(right));
+  if (titleCompare !== 0) {
+    return titleCompare;
+  }
+  return compareText(left.id, right.id);
+};
 
 export const buildTaskGraph = (tasks: TaskDependency[]): TaskGraph => {
   const tasksById = new Map(tasks.map((task) => [task.id, task]));
@@ -25,12 +40,12 @@ export const buildTaskGraph = (tasks: TaskDependency[]): TaskGraph => {
   }
 
   for (const [id, children] of childrenById) {
-    childrenById.set(id, children.sort(compareTasks));
+    childrenById.set(id, children.sort(compareTaskTitles));
   }
 
   const roots = Array.from(nodes.values())
     .filter((node) => node.dependencyIds.length === 0)
-    .sort(compareTasks);
+    .sort(compareTaskTitles);
 
   return { roots, childrenById };
 };

package/src/features/tasks/index.ts

@@ -8,5 +8,14 @@ export {
   type TaskStatus,
 } from "./constants";
 export { createTask } from "./create";
-export { findSchubRoot, listTasks, loadTaskDependencies } from "./filesystem";
+export {
+  archiveTasksForChange,
+  assignTaskToWip,
+  findSchubRoot,
+  listTasks,
+  listTasksForChange,
+  loadTaskDependencies,
+  updateTaskStatuses,
+} from "./filesystem";
 export { buildTaskGraph, renderTaskGraphLines, trimTaskTitle } from "./graph";
+export { createTaskWorktree } from "./worktree";