@nijaru/tk 0.0.4 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nijaru/tk",
-	"version": "0.0.4",
+	"version": "0.0.5",
 	"description": "Minimal task tracker",
 	"type": "module",
 	"bin": {

package/src/cli.test.ts

@@ -57,6 +57,19 @@ describe("tk CLI", () => {
     expect(lsHelp).toContain("--status");
   });
 
+  test("tk mv --help shows mv help", async () => {
+    const { stdout, exitCode } = await run(["mv", "--help"], testDir);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("tk mv");
+    expect(stdout).toContain("<project>");
+  });
+
+  test("tk move --help shows move help", async () => {
+    const { stdout, exitCode } = await run(["move", "--help"], testDir);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("tk move");
+  });
+
   test("help <command> shows command-specific help", async () => {
     const { stdout, exitCode } = await run(["help", "add"], testDir);
     expect(exitCode).toBe(0);
@@ -320,6 +333,62 @@ describe("tk CLI", () => {
       expect(lines[0]).toContain("Done Second");
       expect(lines[1]).toContain("Done First");
     });
+
+    test("shows [due today] annotation for task due today", async () => {
+      await run(["add", "Due Today Task", "--due", "+0d"], testDir);
+
+      const { stdout } = await run(["ls"], testDir);
+      expect(stdout).toContain("[due today]");
+    });
+
+    test("shows [due Nd] annotation for task due within threshold", async () => {
+      await run(["add", "Due Soon Task", "--due", "+3d"], testDir);
+
+      const { stdout } = await run(["ls"], testDir);
+      expect(stdout).toContain("[due 3d]");
+    });
+
+    test("no due-soon annotation for task due beyond threshold", async () => {
+      await run(["add", "Far Future Task", "--due", "2099-01-01"], testDir);
+
+      const { stdout } = await run(["ls"], testDir);
+      expect(stdout).not.toContain("[due ");
+    });
+
+    test("no due-soon annotation for overdue task (shows [OVERDUE] instead)", async () => {
+      await run(["add", "Overdue Task", "--due", "2020-01-01"], testDir);
+
+      const { stdout } = await run(["ls"], testDir);
+      expect(stdout).toContain("[OVERDUE]");
+      expect(stdout).not.toContain("[due today]");
+    });
+
+    test("--json includes days_until_due field", async () => {
+      await run(["add", "Due Today", "--due", "+0d"], testDir);
+
+      const { stdout } = await run(["ls", "--json"], testDir);
+      const tasks = JSON.parse(stdout);
+      expect(tasks[0]).toHaveProperty("days_until_due");
+      expect(tasks[0].days_until_due).toBe(0);
+    });
+  });
+
+  describe("show (due-soon)", () => {
+    test("shows [due today] in detail view", async () => {
+      const { stdout: idOut } = await run(["add", "Due Today", "--due", "+0d"], testDir);
+      const id = idOut.trim();
+
+      const { stdout } = await run(["show", id], testDir);
+      expect(stdout).toContain("[due today]");
+    });
+
+    test("shows [due Nd] in detail view", async () => {
+      const { stdout: idOut } = await run(["add", "Due Soon", "--due", "+4d"], testDir);
+      const id = idOut.trim();
+
+      const { stdout } = await run(["show", id], testDir);
+      expect(stdout).toContain("[due 4d]");
+    });
   });
 
   describe("ready", () => {
@@ -604,25 +673,29 @@ describe("tk CLI", () => {
   describe("init", () => {
     test("creates .tasks directory", async () => {
       const newDir = mkdtempSync(join(tmpdir(), "tk-init-"));
-      Bun.spawnSync(["git", "init"], { cwd: newDir });
-
-      const { stdout, exitCode } = await run(["init"], newDir);
-      expect(exitCode).toBe(0);
-      expect(stdout).toContain("Initialized");
-      expect(existsSync(join(newDir, ".tasks"))).toBe(true);
-
-      rmSync(newDir, { recursive: true, force: true });
+      try {
+        Bun.spawnSync(["git", "init"], { cwd: newDir });
+
+        const { stdout, exitCode } = await run(["init"], newDir);
+        expect(exitCode).toBe(0);
+        expect(stdout).toContain("Initialized");
+        expect(existsSync(join(newDir, ".tasks"))).toBe(true);
+      } finally {
+        rmSync(newDir, { recursive: true, force: true });
+      }
     });
 
     test("creates .tasks with custom project", async () => {
       const newDir = mkdtempSync(join(tmpdir(), "tk-init-"));
-      Bun.spawnSync(["git", "init"], { cwd: newDir });
-
-      await run(["init", "-P", "api"], newDir);
-      const { stdout } = await run(["add", "Task"], newDir);
-      expect(stdout).toMatch(/^api-[a-z0-9]{4}$/);
-
-      rmSync(newDir, { recursive: true, force: true });
+      try {
+        Bun.spawnSync(["git", "init"], { cwd: newDir });
+
+        await run(["init", "-P", "api"], newDir);
+        const { stdout } = await run(["add", "Task"], newDir);
+        expect(stdout).toMatch(/^api-[a-z0-9]{4}$/);
+      } finally {
+        rmSync(newDir, { recursive: true, force: true });
+      }
     });
 
     test("reports already initialized", async () => {
@@ -661,15 +734,6 @@ describe("tk CLI", () => {
       expect(stdout).toMatch(/^api-[a-z0-9]{4}$/);
     });
 
-    test("manages aliases", async () => {
-      await run(["init"], testDir);
-      await run(["config", "alias", "api", "packages/api"], testDir);
-
-      const { stdout } = await run(["config", "alias"], testDir);
-      expect(stdout).toContain("api");
-      expect(stdout).toContain("packages/api");
-    });
-
     test("renames project and updates references", async () => {
       await run(["init", "-P", "old"], testDir);
 
@@ -804,22 +868,14 @@ describe("tk CLI", () => {
     });
 
     test("ambiguous ID shows matching tasks", async () => {
-      // Create tasks with same ref prefix in different projects
-      const { stdout: id1 } = await run(["add", "Task 1", "-P", "api"], testDir);
-      const { stdout: id2 } = await run(["add", "Task 2", "-P", "web"], testDir);
-      const ref1 = id1.trim().split("-")[1] ?? "";
-      const ref2 = id2.trim().split("-")[1] ?? "";
-
-      // Use first char which might match both
-      const prefix = ref1[0] ?? "";
-
-      // Only test if both refs start with same char (otherwise not ambiguous)
-      if (ref2.startsWith(prefix)) {
-        const { stderr, exitCode } = await run(["show", prefix], testDir);
-        expect(exitCode).toBe(1);
-        expect(stderr).toContain("Ambiguous");
-        expect(stderr).toContain("matches");
-      }
+      // Two tasks in the same project share the "api-" prefix — guaranteed ambiguous
+      await run(["add", "Task 1", "-P", "api"], testDir);
+      await run(["add", "Task 2", "-P", "api"], testDir);
+
+      const { stderr, exitCode } = await run(["show", "api"], testDir);
+      expect(exitCode).toBe(1);
+      expect(stderr).toContain("Ambiguous");
+      expect(stderr).toContain("matches");
     });
 
     test("not found shows clear error", async () => {
@@ -973,4 +1029,144 @@ describe("tk CLI", () => {
       expect(result).toHaveProperty("unfixable");
     });
   });
+
+  describe("mv", () => {
+    test("moves task to a different project", async () => {
+      await run(["init"], testDir);
+      const { stdout: idOut } = await run(["add", "Move me", "-P", "src"], testDir);
+      const oldId = idOut.trim();
+      const ref = oldId.split("-")[1];
+
+      const { stdout, exitCode } = await run(["mv", oldId, "dst"], testDir);
+      expect(exitCode).toBe(0);
+      const newId = `dst-${ref}`;
+      expect(stdout).toContain(oldId);
+      expect(stdout).toContain(newId);
+
+      // Old ID gone, new ID exists with same content
+      const { exitCode: notFound } = await run(["show", oldId], testDir);
+      expect(notFound).toBe(1);
+
+      const { stdout: showOut } = await run(["show", newId, "--json"], testDir);
+      const task = JSON.parse(showOut);
+      expect(task.project).toBe("dst");
+      expect(task.title).toBe("Move me");
+    });
+
+    test("updates blocked_by and parent references", async () => {
+      await run(["init"], testDir);
+      const { stdout: idA } = await run(["add", "A", "-P", "src"], testDir);
+      const { stdout: idB } = await run(["add", "B", "-P", "src"], testDir);
+      const aId = idA.trim();
+      const bId = idB.trim();
+
+      // B is blocked by A, and B has A as parent
+      await run(["block", bId, aId], testDir);
+      await run(["edit", bId, "--parent", aId], testDir);
+
+      const ref = aId.split("-")[1];
+      await run(["mv", aId, "dst"], testDir);
+      const newAId = `dst-${ref}`;
+
+      const { stdout: showB } = await run(["show", bId, "--json"], testDir);
+      const bTask = JSON.parse(showB);
+      expect(bTask.blocked_by).toContain(newAId);
+      expect(bTask.parent).toBe(newAId);
+    });
+
+    test("errors when moving to same project", async () => {
+      await run(["init"], testDir);
+      const { stdout: idOut } = await run(["add", "Task", "-P", "api"], testDir);
+      const id = idOut.trim();
+
+      const { stderr, exitCode } = await run(["mv", id, "api"], testDir);
+      expect(exitCode).toBe(1);
+      expect(stderr).toContain("already in project");
+    });
+
+    test("errors on ref collision", async () => {
+      await run(["init"], testDir);
+      const { stdout: idOut } = await run(["add", "Task A", "-P", "src"], testDir);
+      const id = idOut.trim();
+      const ref = id.split("-")[1]!;
+
+      // Manually create a collision in dst project
+      const fs = await import("fs");
+      const path = await import("path");
+      const collisionPath = path.join(testDir, ".tasks", `dst-${ref}.json`);
+      fs.writeFileSync(
+        collisionPath,
+        JSON.stringify({
+          project: "dst",
+          ref,
+          title: "Collision",
+          status: "open",
+          priority: 3,
+          labels: [],
+          assignees: [],
+          parent: null,
+          blocked_by: [],
+          estimate: null,
+          due_date: null,
+          logs: [],
+          description: null,
+          created_at: new Date().toISOString(),
+          updated_at: new Date().toISOString(),
+          completed_at: null,
+          external: {},
+        }),
+      );
+
+      const { stderr, exitCode } = await run(["mv", id, "dst"], testDir);
+      expect(exitCode).toBe(1);
+      expect(stderr).toContain("already exists");
+    });
+
+    test("errors on missing arguments", async () => {
+      await run(["init"], testDir);
+      const { stdout: idOut } = await run(["add", "Task"], testDir);
+      const id = idOut.trim();
+
+      const { stderr: noProject } = await run(["mv", id], testDir);
+      expect(noProject).toContain("Project required");
+    });
+
+    test("errors on invalid project name", async () => {
+      await run(["init"], testDir);
+      const { stdout: idOut } = await run(["add", "Task", "-P", "src"], testDir);
+      const id = idOut.trim();
+
+      const { stderr, exitCode } = await run(["mv", id, "Bad-Project"], testDir);
+      expect(exitCode).toBe(1);
+      expect(stderr).toContain("Invalid project name");
+    });
+
+    test("--json output structure", async () => {
+      await run(["init"], testDir);
+      const { stdout: idOut } = await run(["add", "Task", "-P", "src"], testDir);
+      const id = idOut.trim();
+
+      const { stdout, exitCode } = await run(["mv", id, "dst", "--json"], testDir);
+      expect(exitCode).toBe(0);
+      const result = JSON.parse(stdout);
+      expect(result).toHaveProperty("old_id");
+      expect(result).toHaveProperty("new_id");
+      expect(result).toHaveProperty("referencesUpdated");
+    });
+
+    test("partial ID resolution", async () => {
+      await run(["init"], testDir);
+      const { stdout: idOut } = await run(["add", "Task", "-P", "src"], testDir);
+      const id = idOut.trim();
+      const ref = id.split("-")[1]!;
+
+      // Use just the ref as partial ID
+      const { exitCode } = await run(["mv", ref, "dst"], testDir);
+      expect(exitCode).toBe(0);
+
+      // Verify moved
+      const { exitCode: found } = await run(["show", `dst-${ref}`], testDir);
+      expect(found).toBe(0);
+    });
+  });
 });

package/src/cli.ts

@@ -308,8 +308,9 @@ function main() {
       const { values } = parseArgs({
         args,
         options: {
-          ...COMMON_OPTIONS,
-          label: COMMON_OPTIONS.labels, // alias for consistency
+          project: { type: "string", short: "P" },
+          priority: { type: "string", short: "p" },
+          label: { type: "string", short: "l" },
           status: { type: "string", short: "s" },
           assignee: { type: "string" },
           parent: { type: "string" },
@@ -337,7 +338,7 @@ function main() {
         status,
         priority,
         project: values.project,
-        label: values.label ?? values.labels,
+        label: values.label,
         assignee: values.assignee,
         parent: parentFilter,
         roots: values.roots,
@@ -402,12 +403,12 @@ function main() {
       let labels: string[] | undefined;
       if (values.labels) {
         if (values.labels.startsWith("+")) {
-          // Add label (avoid duplicates)
-          const newLabel = values.labels.slice(1);
+          const newLabel = values.labels.slice(1).trim();
+          if (!newLabel) throw new Error("Label name required after '+'");
           labels = task.labels.includes(newLabel) ? task.labels : [...task.labels, newLabel];
         } else if (values.labels.startsWith("-")) {
-          // Remove label
-          const removeLabel = values.labels.slice(1);
+          const removeLabel = values.labels.slice(1).trim();
+          if (!removeLabel) throw new Error("Label name required after '-'");
           labels = task.labels.filter((l: string) => l !== removeLabel);
         } else {
           // Replace labels
@@ -430,7 +431,7 @@ function main() {
 
       const updated = storage.updateTask(task.id, {
         title: values.title?.trim() || undefined,
-        description: values.description,
+        description: values.description === "-" ? null : values.description,
         priority: values.priority ? parsePriority(values.priority) : undefined,
         labels,
         assignees: parseAssignees(values.assignees),
@@ -496,6 +497,19 @@ function main() {
       break;
     }
 
+    case "mv":
+    case "move": {
+      const id = resolveId(args[0], "mv");
+      const newProject = args[1];
+      if (!newProject) error("Project required: tk mv <id> <project>");
+      validateProject(newProject);
+      const result = storage.moveTask(id, newProject);
+      const refMsg =
+        result.referencesUpdated > 0 ? `\nUpdated ${result.referencesUpdated} references` : "";
+      output(result, green(`Moved: ${result.old_id} → ${result.new_id}${refMsg}`));
+      break;
+    }
+
     case "clean": {
       const config = storage.getConfig();
       const { values } = parseArgs({
@@ -616,46 +630,8 @@ function main() {
           }
           break;
         }
-        case "alias": {
-          const { values, positionals } = parseArgs({
-            args: args.slice(1),
-            options: {
-              rm: { type: "string" },
-              list: { type: "boolean" },
-            },
-            allowPositionals: true,
-          });
-
-          if (values.rm) {
-            const updated = storage.removeAlias(values.rm);
-            output(updated, green(`Removed alias: ${values.rm}`));
-          } else if (positionals.length >= 2) {
-            const alias = positionals[0];
-            const path = positionals[1];
-            if (!alias || !path || !alias.trim()) {
-              error("Alias name and path required: tk config alias <name> <path>");
-            }
-            const updated = storage.setAlias(alias, path);
-            output(updated, green(`Added alias: ${alias} → ${path}`));
-          } else {
-            // List aliases
-            const aliases = config.aliases;
-            if (Object.keys(aliases).length === 0) {
-              output(
-                { aliases: {} },
-                "No aliases defined. Add one with: tk config alias <name> <path>",
-              );
-            } else {
-              const lines = Object.entries(aliases)
-                .map(([a, p]) => `${a} → ${p}`)
-                .join("\n");
-              output({ aliases }, lines);
-            }
-          }
-          break;
-        }
         default:
-          error(`Unknown config command: ${subcommand}. Valid: project, alias.`);
+          error(`Unknown config command: ${subcommand}. Valid: project.`);
       }
       break;
     }

package/src/db/storage.ts

@@ -11,7 +11,7 @@ import {
 } from "fs";
 import { join, resolve, basename } from "path";
 import { getTasksDir, getWorkingDir } from "../lib/root";
-import { isTaskOverdue } from "../lib/time";
+import { isTaskOverdue, daysUntilDue } from "../lib/time";
 import type { Task, Config, Status, Priority, TaskWithMeta, LogEntry } from "../types";
 import { DEFAULT_CONFIG, taskId, parseId, generateRef } from "../types";
 
@@ -77,8 +77,8 @@ const STATUS_ORDER: Record<Status, number> = { active: 0, open: 1, done: 2 };
  * 3. If done: completed_at (newest first)
  */
 export function compareTasks(a: Task, b: Task): number {
-  const sA = STATUS_ORDER[a.status] ?? 99;
-  const sB = STATUS_ORDER[b.status] ?? 99;
+  const sA = STATUS_ORDER[a.status];
+  const sB = STATUS_ORDER[b.status];
   if (sA !== sB) return sA - sB;
 
   if (a.status !== "done") {
@@ -119,7 +119,12 @@ export function getConfig(): Config {
   }
   try {
     const text = readFileSync(configPath, "utf-8");
-    return { ...DEFAULT_CONFIG, ...JSON.parse(text) };
+    const parsed = JSON.parse(text);
+    return {
+      ...DEFAULT_CONFIG,
+      ...parsed,
+      defaults: { ...DEFAULT_CONFIG.defaults, ...parsed.defaults },
+    };
   } catch {
     return { ...DEFAULT_CONFIG };
   }
@@ -234,18 +239,75 @@ export function renameProject(oldProject: string, newProject: string): RenameRes
   };
 }
 
-export function setAlias(alias: string, path: string): Config {
-  const config = getConfig();
-  config.aliases[alias] = path;
-  saveConfig(config);
-  return config;
+export interface MoveResult {
+  old_id: string;
+  new_id: string;
+  referencesUpdated: number;
 }
 
-export function removeAlias(alias: string): Config {
-  const config = getConfig();
-  delete config.aliases[alias];
-  saveConfig(config);
-  return config;
+export function moveTask(oldId: string, newProject: string): MoveResult {
+  const tasksDir = getTasksDir();
+  if (!existsSync(tasksDir)) {
+    throw new Error("No .tasks/ directory found");
+  }
+
+  const parsed = parseId(oldId);
+  if (!parsed) {
+    throw new Error(`Invalid task ID: ${oldId}`);
+  }
+
+  if (parsed.project === newProject) {
+    throw new Error(`Task ${oldId} is already in project "${newProject}"`);
+  }
+
+  const oldPath = getTaskPath(tasksDir, oldId);
+  if (!existsSync(oldPath)) {
+    throw new Error(`Task not found: ${oldId}`);
+  }
+
+  const newId = `${newProject}-${parsed.ref}`;
+  const newPath = getTaskPath(tasksDir, newId);
+  if (existsSync(newPath)) {
+    throw new Error(
+      `Cannot move: "${newId}" already exists. The ref conflicts with an existing task.`,
+    );
+  }
+
+  const task = readTaskFile(oldPath, tasksDir);
+  if (!task) {
+    throw new Error(`Failed to read task: ${oldId}`);
+  }
+
+  // Write new file with updated project
+  task.project = newProject;
+  task.updated_at = new Date().toISOString();
+  atomicWrite(newPath, JSON.stringify(task, null, 2));
+  unlinkSync(oldPath);
+
+  // Update all blocked_by and parent refs in other tasks
+  let referencesUpdated = 0;
+  const allTasks = getAllTasks(tasksDir);
+  for (const other of allTasks) {
+    let modified = false;
+
+    if (other.blocked_by.includes(oldId)) {
+      other.blocked_by = other.blocked_by.map((id) => (id === oldId ? newId : id));
+      referencesUpdated++;
+      modified = true;
+    }
+
+    if (other.parent === oldId) {
+      other.parent = newId;
+      referencesUpdated++;
+      modified = true;
+    }
+
+    if (modified) {
+      atomicWrite(getTaskPath(tasksDir, taskId(other)), JSON.stringify(other, null, 2));
+    }
+  }
+
+  return { old_id: oldId, new_id: newId, referencesUpdated };
 }
 
 // --- Task File Operations ---
@@ -282,7 +344,8 @@ function isValidTaskStructure(obj: unknown): obj is Task {
     typeof t.ref === "string" &&
     typeof t.title === "string" &&
     typeof t.status === "string" &&
-    Array.isArray(t.blocked_by)
+    Array.isArray(t.blocked_by) &&
+    Array.isArray(t.logs)
   );
 }
 
@@ -513,6 +576,7 @@ export function enrichTask(task: Task, statusMap?: Map<string, Status>): TaskWit
     id: taskId(task),
     is_overdue: isTaskOverdue(task.due_date, task.status),
     blocked_by_incomplete: blockedByIncomplete,
+    days_until_due: daysUntilDue(task.due_date, task.status),
   };
 }
 
@@ -594,9 +658,6 @@ export function getTask(id: string): TaskResult | null {
   };
 }
 
-// Deprecated alias for getTask
-export const getTaskWithMeta = getTask;
-
 export interface ListOptions {
   status?: Status;
   priority?: Priority;
@@ -685,7 +746,7 @@ export function updateTaskStatus(id: string, status: Status): (Task & { id: stri
 
 export interface UpdateTaskOptions {
   title?: string;
-  description?: string;
+  description?: string | null;
   priority?: Priority;
   labels?: string[];
   assignees?: string[];
@@ -884,38 +945,13 @@ export function resolveId(input: string): string | null {
   const tasksDir = getTasksDir();
   if (!existsSync(tasksDir)) return null;
 
-  // If it's already a full valid ID, check if task exists
-  if (parseId(input)) {
-    if (existsSync(getTaskPath(tasksDir, input))) {
-      return input;
-    }
-  }
-
-  const inputLower = input.toLowerCase();
-
-  // Read filenames only (no file content parsing)
-  const files = readdirSync(tasksDir);
-  const matches: string[] = [];
-
-  for (const file of files) {
-    if (!file.endsWith(".json") || file === "config.json") continue;
-
-    // Extract ID from filename: "project-ref.json" -> "project-ref"
-    const id = file.slice(0, -5);
-    if (!parseId(id)) continue;
-
-    // Match by full ID prefix or just ref prefix
-    const ref = id.split("-")[1] ?? "";
-    if (id.startsWith(inputLower) || ref.startsWith(inputLower)) {
-      matches.push(id);
-    }
-  }
-
-  if (matches.length === 1 && matches[0]) {
-    return matches[0];
+  // Fast path: full valid ID that exists
+  if (parseId(input) && existsSync(getTaskPath(tasksDir, input))) {
+    return input;
   }
 
-  return null;
+  const matches = findMatchingIds(input);
+  return matches.length === 1 ? (matches[0] ?? null) : null;
 }
 
 export function findMatchingIds(input: string): string[] {

package/src/lib/completions.ts

@@ -12,7 +12,7 @@ _tk() {
     local cur prev words cword
     _init_completion || return
 
-    local commands="init add ls list ready show start done reopen edit log block unblock rm remove clean check config completions help"
+    local commands="init add ls list ready show start done reopen edit log block unblock mv move rm remove clean check config completions help"
     local global_opts="--json --help -h --version -V"
 
     # Find the command (first non-option word after 'tk')
@@ -60,6 +60,13 @@ _tk() {
                 COMPREPLY=($(compgen -W "$(_tk_task_ids)" -- "$cur"))
             fi
             ;;
+        mv|move)
+            if [[ "$cur" == -* ]]; then
+                COMPREPLY=($(compgen -W "--json" -- "$cur"))
+            else
+                COMPREPLY=($(compgen -W "$(_tk_task_ids)" -- "$cur"))
+            fi
+            ;;
         edit)
             if [[ "$cur" == -* ]]; then
                 COMPREPLY=($(compgen -W "-t --title -d --description -p --priority -l --labels -A --assignees --parent --estimate --due --json" -- "$cur"))
@@ -90,9 +97,7 @@ _tk() {
             ;;
         config)
             if [[ "$prev" == "config" ]]; then
-                COMPREPLY=($(compgen -W "project alias --rm" -- "$cur"))
-            elif [[ "$prev" == "alias" ]]; then
-                COMPREPLY=($(compgen -W "--rm" -- "$cur"))
+                COMPREPLY=($(compgen -W "project" -- "$cur"))
             fi
             ;;
         init)
@@ -139,6 +144,8 @@ _tk() {
         'log:Add log entry'
         'block:Add blocker'
         'unblock:Remove blocker'
+        'mv:Move task to different project'
+        'move:Move task to different project'
         'rm:Delete task'
         'remove:Delete task'
         'clean:Remove old done tasks'
@@ -207,6 +214,12 @@ _tk() {
                         '--json[Output as JSON]' \
                         '1:task id:_tk_task_ids'
                     ;;
+                mv|move)
+                    _arguments \
+                        '--json[Output as JSON]' \
+                        '1:task id:_tk_task_ids' \
+                        '2:project:'
+                    ;;
                 edit)
                     _arguments \
                         '(-t --title)'{-t,--title}'[Title]:title:' \
@@ -244,8 +257,7 @@ _tk() {
                     ;;
                 config)
                     _arguments \
-                        '--rm[Remove alias]' \
-                        '1:subcommand:(project alias)'
+                        '1:subcommand:(project)'
                     ;;
                 init)
                     _arguments \
@@ -332,6 +344,8 @@ complete -c tk -n __tk_needs_command -f -a edit -d 'Edit task'
 complete -c tk -n __tk_needs_command -f -a log -d 'Add log entry'
 complete -c tk -n __tk_needs_command -f -a block -d 'Add blocker'
 complete -c tk -n __tk_needs_command -f -a unblock -d 'Remove blocker'
+complete -c tk -n __tk_needs_command -f -a mv -d 'Move task to different project'
+complete -c tk -n __tk_needs_command -f -a move -d 'Move task to different project'
 complete -c tk -n __tk_needs_command -f -a rm -d 'Delete task'
 complete -c tk -n __tk_needs_command -f -a remove -d 'Delete task'
 complete -c tk -n __tk_needs_command -f -a clean -d 'Remove old done tasks'
@@ -380,6 +394,8 @@ complete -c tk -n '__tk_using_command show' -f -a '(__tk_task_ids)' -d 'Task ID'
 complete -c tk -n '__tk_using_command start' -f -a '(__tk_task_ids)' -d 'Task ID'
 complete -c tk -n '__tk_using_command done' -f -a '(__tk_task_ids)' -d 'Task ID'
 complete -c tk -n '__tk_using_command reopen' -f -a '(__tk_task_ids)' -d 'Task ID'
+complete -c tk -n '__tk_using_command mv' -f -a '(__tk_task_ids)' -d 'Task ID'
+complete -c tk -n '__tk_using_command move' -f -a '(__tk_task_ids)' -d 'Task ID'
 complete -c tk -n '__tk_using_command rm' -f -a '(__tk_task_ids)' -d 'Task ID'
 complete -c tk -n '__tk_using_command remove' -f -a '(__tk_task_ids)' -d 'Task ID'
 complete -c tk -n '__tk_using_command log' -f -a '(__tk_task_ids)' -d 'Task ID'
@@ -414,8 +430,7 @@ complete -c tk -n '__tk_using_command clean' -l json -d 'Output as JSON'
 complete -c tk -n '__tk_using_command check' -l json -d 'Output as JSON'
 
 # config command
-complete -c tk -n '__tk_using_command config' -f -a 'project alias' -d 'Config option'
-complete -c tk -n '__tk_using_command config' -l rm -d 'Remove alias'
+complete -c tk -n '__tk_using_command config' -f -a 'project' -d 'Config option'
 
 # init command
 complete -c tk -n '__tk_using_command init' -s P -l project -d 'Project'

package/src/lib/format.test.ts

@@ -33,7 +33,8 @@ describe("shouldUseColor", () => {
 
   test("respects NO_COLOR empty string as color enabled", () => {
     process.env.NO_COLOR = "";
-    // When NO_COLOR is empty, color is allowed (depends on TTY)
+    // NO_COLOR="" is treated as unset — color depends on TTY (always false in tests)
+    expect(shouldUseColor()).toBe(false);
   });
 });
 
@@ -59,6 +60,7 @@ describe("formatTaskRow", () => {
     external: {},
     blocked_by_incomplete: false,
     is_overdue: false,
+    days_until_due: null,
   };
 
   test("formats task without color", () => {
@@ -127,6 +129,72 @@ describe("formatTaskRow", () => {
     const result = formatTaskRow(todayTask, false);
     expect(result).not.toContain("[OVERDUE]");
   });
+
+  test("shows [due today] for tasks due today", () => {
+    const today = new Date().toISOString().split("T")[0] ?? null;
+    const todayTask: TaskWithMeta = {
+      ...task,
+      due_date: today,
+      is_overdue: false,
+      days_until_due: 0,
+    };
+    const result = formatTaskRow(todayTask, false);
+    expect(result).toContain("[due today]");
+    expect(result).not.toContain("[OVERDUE]");
+  });
+
+  test("shows [due Nd] for tasks due in N days within threshold", () => {
+    const future = new Date();
+    future.setDate(future.getDate() + 3);
+    const dateStr = future.toISOString().split("T")[0] ?? null;
+    const soonTask: TaskWithMeta = {
+      ...task,
+      due_date: dateStr,
+      is_overdue: false,
+      days_until_due: 3,
+    };
+    const result = formatTaskRow(soonTask, false);
+    expect(result).toContain("[due 3d]");
+  });
+
+  test("shows no due-soon marker at 8 days", () => {
+    const future = new Date();
+    future.setDate(future.getDate() + 8);
+    const dateStr = future.toISOString().split("T")[0] ?? null;
+    const notSoonTask: TaskWithMeta = {
+      ...task,
+      due_date: dateStr,
+      is_overdue: false,
+      days_until_due: 8,
+    };
+    const result = formatTaskRow(notSoonTask, false);
+    expect(result).not.toContain("[due");
+    expect(result).not.toContain("[OVERDUE]");
+  });
+
+  test("shows no due-soon marker when overdue", () => {
+    const overdueWithSoon: TaskWithMeta = {
+      ...task,
+      due_date: "2020-01-01",
+      is_overdue: true,
+      days_until_due: null,
+    };
+    const result = formatTaskRow(overdueWithSoon, false);
+    expect(result).toContain("[OVERDUE]");
+    expect(result).not.toContain("[due today]");
+    expect(result).not.toContain("[due ");
+  });
+
+  test("shows no due-soon marker for done tasks", () => {
+    const doneTask: TaskWithMeta = {
+      ...task,
+      status: "done",
+      days_until_due: null,
+      completed_at: new Date().toISOString(),
+    };
+    const result = formatTaskRow(doneTask, false);
+    expect(result).not.toContain("[due");
+  });
 });
 
 describe("formatTaskList", () => {
@@ -161,6 +229,7 @@ describe("formatTaskList", () => {
         external: {},
         blocked_by_incomplete: false,
         is_overdue: false,
+        days_until_due: null,
       },
     ];
     const result = formatTaskList(tasks, false);
@@ -194,6 +263,7 @@ describe("formatTaskList", () => {
         external: {},
         blocked_by_incomplete: false,
         is_overdue: false,
+        days_until_due: null,
       },
       {
         id: "tk-c3d4",
@@ -216,6 +286,7 @@ describe("formatTaskList", () => {
         external: {},
         blocked_by_incomplete: false,
         is_overdue: false,
+        days_until_due: null,
       },
     ];
     const result = formatTaskList(tasks, false);
@@ -248,6 +319,7 @@ describe("formatTaskDetail", () => {
     external: {},
     blocked_by_incomplete: true,
     is_overdue: false,
+    days_until_due: null,
   };
 
   test("includes all task fields", () => {

package/src/lib/format.ts

@@ -1,7 +1,9 @@
 import type { TaskWithMeta, LogEntry } from "../types";
 import { PRIORITY_COLORS, STATUS_COLORS, OVERDUE_COLOR, RESET } from "../types";
 import { formatPriority } from "./priority";
-import { formatDate, formatRelativeTime } from "./time";
+import { formatDate, formatRelativeTime, DUE_SOON_THRESHOLD } from "./time";
+
+const DUE_SOON_COLOR = "\x1b[33m"; // yellow
 
 // Message colors
 const GREEN = "\x1b[32m";
@@ -10,17 +12,14 @@ const YELLOW = "\x1b[33m";
 const DIM = "\x1b[2m";
 
 /**
- * Determines if color output should be used.
+ * Determines if color output should be used for the given stream.
  * Respects NO_COLOR env var (https://no-color.org/) and TTY detection.
  */
-export function shouldUseColor(): boolean {
+export function shouldUseColor(stream: NodeJS.WriteStream = process.stdout): boolean {
   if (process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== "") {
     return false;
   }
-  if (!process.stdout.isTTY) {
-    return false;
-  }
-  return true;
+  return stream.isTTY ?? false;
 }
 
 /** Format text green (success) */
@@ -28,9 +27,9 @@ export function green(msg: string): string {
   return shouldUseColor() ? `${GREEN}${msg}${RESET}` : msg;
 }
 
-/** Format text red (error) */
+/** Format text red (error) — checks stderr since errors are written there */
 export function red(msg: string): string {
-  return shouldUseColor() ? `${RED}${msg}${RESET}` : msg;
+  return shouldUseColor(process.stderr) ? `${RED}${msg}${RESET}` : msg;
 }
 
 /** Format text yellow (warning) */
@@ -64,8 +63,9 @@ export function formatTaskRow(task: TaskWithMeta, useColor?: boolean): string {
   const color = useColor ?? shouldUseColor();
   const id = formatId(task.id).padEnd(11);
   const priority = formatPriority(task.priority).padEnd(4);
-  const title = truncate(task.title, 50);
   const isOverdue = task.is_overdue;
+  const dueSoon =
+    !isOverdue && task.days_until_due !== null && task.days_until_due <= DUE_SOON_THRESHOLD;
 
   let statusText: string = task.status;
   if (task.status === "done" && task.completed_at) {
@@ -75,13 +75,19 @@ export function formatTaskRow(task: TaskWithMeta, useColor?: boolean): string {
 
   if (color) {
     const pc = PRIORITY_COLORS[task.priority];
-    const sc = isOverdue ? OVERDUE_COLOR : STATUS_COLORS[task.status];
+    const sc = isOverdue ? OVERDUE_COLOR : dueSoon ? DUE_SOON_COLOR : STATUS_COLORS[task.status];
     const tc = task.status === "done" ? DIM : "";
+    const title = truncate(task.title, 50);
     return `${id} | ${pc}${priority}${RESET} | ${sc}${status}${RESET} | ${tc}${title}${RESET}`;
   }
 
+  let dueSoonMarker = "";
+  if (dueSoon) {
+    dueSoonMarker = task.days_until_due === 0 ? " [due today]" : ` [due ${task.days_until_due}d]`;
+  }
   const overdueMarker = isOverdue ? " [OVERDUE]" : "";
-  return `${id} | ${priority} | ${status} | ${title}${overdueMarker}`;
+  const title = truncate(task.title, 50);
+  return `${id} | ${priority} | ${status} | ${title}${overdueMarker}${dueSoonMarker}`;
 }
 
 export function formatTaskList(
@@ -136,8 +142,16 @@ export function formatTaskDetail(task: TaskWithMeta, logs: LogEntry[], useColor?
   }
 
   if (task.due_date) {
+    const yc = color ? DUE_SOON_COLOR : "";
+    const dueSoon =
+      !task.is_overdue && task.days_until_due !== null && task.days_until_due <= DUE_SOON_THRESHOLD;
+    let dueSoonStr = "";
+    if (dueSoon) {
+      const marker = task.days_until_due === 0 ? "[due today]" : `[due ${task.days_until_due}d]`;
+      dueSoonStr = ` ${yc}${marker}${r}`;
+    }
     const overdueStr = task.is_overdue ? ` ${oc}[OVERDUE]${r}` : "";
-    lines.push(`Due:         ${task.due_date}${overdueStr}`);
+    lines.push(`Due:         ${task.due_date}${overdueStr}${dueSoonStr}`);
   }
 
   lines.push(`Created:     ${formatDate(task.created_at)}`);
@@ -167,22 +181,9 @@ export function formatJson(data: unknown): string {
   return JSON.stringify(data, null, 2);
 }
 
-export function formatConfig(config: {
-  version: number;
-  project: string;
-  aliases: Record<string, string>;
-}): string {
+export function formatConfig(config: { version: number; project: string }): string {
   const lines: string[] = [];
   lines.push(`Version:  ${config.version}`);
   lines.push(`Project:  ${config.project}`);
-
-  if (Object.keys(config.aliases).length > 0) {
-    lines.push("");
-    lines.push("Aliases:");
-    for (const [alias, path] of Object.entries(config.aliases)) {
-      lines.push(`  ${alias} → ${path}`);
-    }
-  }
-
   return lines.join("\n");
 }

package/src/lib/help.ts

@@ -18,6 +18,7 @@ COMMANDS:
   log          Add log entry
   block        Add blocker
   unblock      Remove blocker
+  mv, move     Move task to different project
   rm, remove   Delete task
   clean        Remove old done tasks
   check        Check for data issues
@@ -173,6 +174,26 @@ USAGE:
 
 EXAMPLES:
   tk unblock tk-2 tk-1
+`,
+  mv: `tk mv - Move a task to a different project
+
+USAGE:
+  tk mv <id> <project>
+
+Moves a task to a new project, keeping the same ref.
+Errors if the new ID already exists.
+Updates all blocked_by and parent references.
+
+EXAMPLES:
+  tk mv api-a1b2 web        # Moves api-a1b2 → web-a1b2
+  tk mv a1b2 archive        # Partial ID resolution
+`,
+  move: `tk move - Move a task to a different project (alias for 'mv')
+
+USAGE:
+  tk move <id> <project>
+
+Run 'tk mv --help' for options.
 `,
   rm: `tk rm - Delete a task
 
@@ -223,14 +244,10 @@ USAGE:
   tk config project                      Show default project
   tk config project <name>               Set default project
   tk config project <new> --rename <old> Rename project (old-* → new-*)
-  tk config alias                        List aliases
-  tk config alias <name> <path>          Add alias
-  tk config alias --rm <name>            Remove alias
 
 EXAMPLES:
   tk config project api
   tk config project lsmvec --rename cloudlsmvec
-  tk config alias web src/web
 `,
   completions: `tk completions - Output shell completions
 

package/src/lib/time.test.ts

@@ -0,0 +1,222 @@
+import { test, expect, describe } from "bun:test";
+import {
+  isTaskOverdue,
+  daysUntilDue,
+  formatRelativeTime,
+  formatDate,
+  formatLocalDate,
+  parseDueDate,
+  parseEstimate,
+  DUE_SOON_THRESHOLD,
+} from "./time";
+
+describe("isTaskOverdue", () => {
+  test("returns false when no due date", () => {
+    expect(isTaskOverdue(null, "open")).toBe(false);
+  });
+
+  test("returns false for done tasks regardless of date", () => {
+    expect(isTaskOverdue("2020-01-01", "done")).toBe(false);
+  });
+
+  test("returns false for active done tasks", () => {
+    expect(isTaskOverdue("2020-01-01", "done")).toBe(false);
+  });
+
+  test("returns true for past dates (open)", () => {
+    expect(isTaskOverdue("2020-01-01", "open")).toBe(true);
+  });
+
+  test("returns true for past dates (active)", () => {
+    expect(isTaskOverdue("2020-06-15", "active")).toBe(true);
+  });
+
+  test("returns false for today", () => {
+    const today = new Date().toISOString().split("T")[0]!;
+    expect(isTaskOverdue(today, "open")).toBe(false);
+  });
+
+  test("returns false for future dates", () => {
+    const future = new Date();
+    future.setDate(future.getDate() + 7);
+    const dateStr = future.toISOString().split("T")[0]!;
+    expect(isTaskOverdue(dateStr, "open")).toBe(false);
+  });
+
+  test("returns false for invalid date string", () => {
+    expect(isTaskOverdue("not-a-date", "open")).toBe(false);
+  });
+});
+
+describe("daysUntilDue", () => {
+  test("returns null when no due date", () => {
+    expect(daysUntilDue(null, "open")).toBeNull();
+  });
+
+  test("returns null when no due date (active)", () => {
+    expect(daysUntilDue(null, "active")).toBeNull();
+  });
+
+  test("returns null for done tasks", () => {
+    const future = new Date();
+    future.setDate(future.getDate() + 3);
+    const dateStr = future.toISOString().split("T")[0]!;
+    expect(daysUntilDue(dateStr, "done")).toBeNull();
+  });
+
+  test("returns 0 for due today (open)", () => {
+    const today = new Date().toISOString().split("T")[0]!;
+    expect(daysUntilDue(today, "open")).toBe(0);
+  });
+
+  test("returns 0 for due today (active)", () => {
+    const today = new Date().toISOString().split("T")[0]!;
+    expect(daysUntilDue(today, "active")).toBe(0);
+  });
+
+  test("returns N for due in N days", () => {
+    const future = new Date();
+    future.setDate(future.getDate() + 3);
+    const dateStr = future.toISOString().split("T")[0]!;
+    expect(daysUntilDue(dateStr, "open")).toBe(3);
+  });
+
+  test("returns null for past dates (already overdue)", () => {
+    expect(daysUntilDue("2020-01-01", "open")).toBeNull();
+  });
+
+  test("returns null for invalid date string", () => {
+    expect(daysUntilDue("not-a-date", "open")).toBeNull();
+  });
+
+  test("DUE_SOON_THRESHOLD is 7", () => {
+    expect(DUE_SOON_THRESHOLD).toBe(7);
+  });
+});
+
+describe("formatRelativeTime", () => {
+  test("returns 'now' for very recent timestamps", () => {
+    const ts = new Date().toISOString();
+    expect(formatRelativeTime(ts)).toBe("now");
+  });
+
+  test("returns minutes for timestamps minutes ago", () => {
+    const ts = new Date(Date.now() - 5 * 60 * 1000).toISOString();
+    expect(formatRelativeTime(ts)).toBe("5m");
+  });
+
+  test("returns hours for timestamps hours ago", () => {
+    const ts = new Date(Date.now() - 3 * 60 * 60 * 1000).toISOString();
+    expect(formatRelativeTime(ts)).toBe("3h");
+  });
+
+  test("returns days for timestamps days ago", () => {
+    const ts = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000).toISOString();
+    expect(formatRelativeTime(ts)).toBe("2d");
+  });
+});
+
+describe("formatDate", () => {
+  test("returns a non-empty string for a valid ISO timestamp", () => {
+    const result = formatDate("2024-01-15T10:30:00.000Z");
+    expect(typeof result).toBe("string");
+    expect(result.length).toBeGreaterThan(0);
+  });
+});
+
+describe("formatLocalDate", () => {
+  test("formats date as YYYY-MM-DD", () => {
+    const date = new Date(2026, 0, 15); // Jan 15 2026
+    expect(formatLocalDate(date)).toBe("2026-01-15");
+  });
+
+  test("zero-pads month and day", () => {
+    const date = new Date(2026, 1, 5); // Feb 5 2026
+    expect(formatLocalDate(date)).toBe("2026-02-05");
+  });
+});
+
+describe("parseDueDate", () => {
+  test("returns undefined for undefined input", () => {
+    expect(parseDueDate(undefined)).toBeUndefined();
+  });
+
+  test("returns undefined for '-' (clear sentinel)", () => {
+    expect(parseDueDate("-")).toBeUndefined();
+  });
+
+  test("returns valid YYYY-MM-DD unchanged", () => {
+    expect(parseDueDate("2026-06-15")).toBe("2026-06-15");
+  });
+
+  test("parses +Nd relative date", () => {
+    const result = parseDueDate("+7d");
+    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+    const resultDate = new Date(result!);
+    const today = new Date();
+    const diffDays = Math.round((resultDate.getTime() - today.getTime()) / (1000 * 60 * 60 * 24));
+    expect(diffDays).toBeGreaterThanOrEqual(6);
+    expect(diffDays).toBeLessThanOrEqual(8);
+  });
+
+  test("parses +Nw relative date", () => {
+    const result = parseDueDate("+2w");
+    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+  });
+
+  test("parses +Nm relative date", () => {
+    const result = parseDueDate("+1m");
+    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+  });
+
+  test("parses +Nh relative date", () => {
+    const result = parseDueDate("+3h");
+    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+  });
+
+  test("throws for invalid relative format", () => {
+    expect(() => parseDueDate("+7x")).toThrow("Invalid relative date");
+  });
+
+  test("throws for bare + with no content", () => {
+    expect(() => parseDueDate("+")).toThrow("Invalid relative date");
+  });
+
+  test("throws for non-date string", () => {
+    expect(() => parseDueDate("not-a-date")).toThrow("Invalid date format");
+  });
+
+  test("throws for invalid calendar date (month 13)", () => {
+    expect(() => parseDueDate("2026-13-01")).toThrow("Invalid date format");
+  });
+
+  test("throws for invalid calendar date (day 32)", () => {
+    expect(() => parseDueDate("2026-01-32")).toThrow("Invalid date format");
+  });
+});
+
+describe("parseEstimate", () => {
+  test("returns undefined for undefined input", () => {
+    expect(parseEstimate(undefined)).toBeUndefined();
+  });
+
+  test("parses valid integer string", () => {
+    expect(parseEstimate("42")).toBe(42);
+  });
+
+  test("parses zero", () => {
+    expect(parseEstimate("0")).toBe(0);
+  });
+
+  test("throws for non-numeric string", () => {
+    expect(() => parseEstimate("abc")).toThrow("Invalid estimate");
+  });
+
+  test("throws for decimal", () => {
+    expect(() => parseEstimate("3.5")).toThrow("Invalid estimate");
+  });
+
+  test("throws for negative number", () => {
+    expect(() => parseEstimate("-1")).toThrow("Invalid estimate");
+  });
+});

package/src/lib/time.ts

@@ -1,5 +1,7 @@
 import type { Status } from "../types";
 
+export const DUE_SOON_THRESHOLD = 7;
+
 /**
  * Determines if a task is overdue.
  * Done tasks are never overdue.
@@ -12,11 +14,32 @@ export function isTaskOverdue(dueDate: string | null, status: Status): boolean {
   const year = parts[0];
   const month = parts[1];
   const day = parts[2];
-  if (!year || !month || !day) return false;
+  if (year === undefined || !month || !day) return false;
   const due = new Date(year, month - 1, day);
   return due < today;
 }
 
+/**
+ * Returns the number of days until a task is due (0 = today), or null if:
+ * - No due date
+ * - Task is done
+ * - Task is already overdue
+ */
+export function daysUntilDue(dueDate: string | null, status: Status): number | null {
+  if (!dueDate || status === "done") return null;
+  const today = new Date();
+  today.setHours(0, 0, 0, 0);
+  const parts = dueDate.split("-").map(Number);
+  const year = parts[0];
+  const month = parts[1];
+  const day = parts[2];
+  if (year === undefined || !month || !day) return null;
+  const due = new Date(year, month - 1, day);
+  const diffMs = due.getTime() - today.getTime();
+  if (diffMs < 0) return null; // already overdue
+  return Math.round(diffMs / (1000 * 60 * 60 * 24));
+}
+
 /**
  * Format a timestamp into a human-readable relative time (e.g., "2d", "5h").
  */

package/src/types.ts

@@ -51,7 +51,8 @@ export function parseId(id: string): { project: string; ref: string } | null {
 // Generate random 4-char ref (a-z0-9)
 export function generateRef(): string {
   const chars = "abcdefghijklmnopqrstuvwxyz0123456789"; // 36 chars
-  const maxValid = 252; // 36 * 7 - reject >= 252 to avoid modulo bias
+  const charsetLen = chars.length; // 36
+  const maxValid = charsetLen * Math.floor(256 / charsetLen); // 252: reject >= maxValid to avoid modulo bias
   const result: string[] = [];
 
   while (result.length < 4) {
@@ -59,7 +60,7 @@ export function generateRef(): string {
     crypto.getRandomValues(bytes);
     for (const b of bytes) {
       if (b < maxValid && result.length < 4) {
-        result.push(chars[b % 36]!);
+        result.push(chars[b % charsetLen]!);
       }
     }
   }
@@ -70,6 +71,7 @@ export interface TaskWithMeta extends Task {
   id: string; // computed from project-ref
   blocked_by_incomplete: boolean;
   is_overdue: boolean;
+  days_until_due: number | null;
 }
 
 export interface Config {
@@ -80,7 +82,6 @@ export interface Config {
     labels: string[];
     assignees: string[];
   };
-  aliases: Record<string, string>; // alias -> path for auto-project detection
   clean_after: number | false; // days to keep done tasks, or false to disable
 }
 
@@ -92,7 +93,6 @@ export const DEFAULT_CONFIG: Config = {
     labels: [],
     assignees: [],
   },
-  aliases: {},
   clean_after: 14,
 };