@vibetasks/cli 0.4.6 → 0.5.0

package/dist/bin/vibetasks.js

@@ -11,7 +11,7 @@ import {
 } from "../chunk-2KRLRG4G.js";
 
 // bin/vibetasks.ts
-import { Command as Command16 } from "commander";
+import { Command as Command18 } from "commander";
 import { createRequire } from "module";
 
 // src/commands/login.ts
@@ -48,8 +48,17 @@ ${url}
 `));
   }
 }
+function getAuthBaseUrl() {
+  if (process.env.VIBETASKS_AUTH_URL) {
+    return process.env.VIBETASKS_AUTH_URL;
+  }
+  if (process.env.TASKFLOW_WEB_PORT) {
+    return `http://localhost:${process.env.TASKFLOW_WEB_PORT}`;
+  }
+  return "https://vibetasks.dev";
+}
 async function loginWithBrowser() {
-  console.log(chalk.blue.bold("\n\u{1F510} TaskFlow Browser Login\n"));
+  console.log(chalk.blue.bold("\n\u{1F510} VibeTasks Browser Login\n"));
   const spinner = ora("Starting local server...").start();
   const port = await getAvailablePort();
   return new Promise((resolve, reject) => {
@@ -247,12 +256,12 @@ async function loginWithBrowser() {
                 <h1>Authentication Successful!</h1>
                 <p class="email">${email}</p>
                 <p class="message">
-                  Your TaskFlow CLI is now connected to your account.<br>
+                  Your VibeTasks CLI is now connected to your account.<br>
                   You can close this window and return to your terminal.
                 </p>
                 <div class="success-badge">Ready to use</div>
                 <div class="button-group">
-                  <a href="http://localhost:2843/dashboard" class="button button-primary">Go to Dashboard</a>
+                  <a href="https://vibetasks.dev/dashboard" class="button button-primary">Go to Dashboard</a>
                   <button onclick="window.close()" class="button button-secondary">Close Window</button>
                 </div>
               </div>
@@ -263,7 +272,7 @@ async function loginWithBrowser() {
           console.log(chalk.gray(`
 Logged in as: ${email}`));
           console.log(chalk.gray(`Tokens stored in: ${storageLocation}`));
-          console.log(chalk.blue.bold("\n\u2728 You can now use TaskFlow CLI commands\n"));
+          console.log(chalk.blue.bold("\n\u2728 You can now use VibeTasks CLI commands\n"));
           if (timeoutId) clearTimeout(timeoutId);
           resolve();
           server.close(() => {
@@ -308,11 +317,13 @@ Error: ${error.message}`));
     });
     server.listen(port, async () => {
       spinner.text = "Opening browser...";
-      const taskflowPort = process.env.TASKFLOW_WEB_PORT || "2843";
-      const authUrl = `http://localhost:${taskflowPort}/cli-auth?port=${port}`;
+      const baseUrl = getAuthBaseUrl();
+      const authUrl = `${baseUrl}/cli-auth?port=${port}`;
       spinner.text = "Waiting for authentication in browser...";
       console.log(chalk.gray(`
-If browser doesn't open, visit: ${authUrl}
+Opening: ${authUrl}`));
+      console.log(chalk.gray(`
+If browser doesn't open, visit the URL above.
 `));
       await openBrowser(authUrl);
     });
@@ -474,7 +485,227 @@ function parseDate(dateStr) {
 
 // src/commands/add.ts
 import { detectProject } from "@vibetasks/shared/utils/project-detector";
-var addCommand = new Command2("add").description("Add a new task").argument("<title>", "Task title").option("-n, --notes <notes>", "Task notes (markdown supported)").option("-d, --due <date>", 'Due date (YYYY-MM-DD, "today", "tomorrow", "+3d")').option("-p, --priority <level>", "Priority: low, medium, high", "none").option("-t, --tags <tags...>", "Tags (space-separated)").option("--project <name>", "Override auto-detected project").option("-e, --energy <level>", "Energy required: low, medium, high").action(async (title, options) => {
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/utils/session-manager.ts
+import { writeFile, readFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import { randomUUID } from "crypto";
+var ADJECTIVES = [
+  "swift",
+  "calm",
+  "bold",
+  "warm",
+  "cool",
+  "bright",
+  "dark",
+  "quick",
+  "slow",
+  "wise",
+  "keen",
+  "soft",
+  "loud",
+  "deep",
+  "high",
+  "low"
+];
+var NOUNS = [
+  "fox",
+  "owl",
+  "bear",
+  "wolf",
+  "hawk",
+  "moon",
+  "star",
+  "sun",
+  "tree",
+  "wave",
+  "wind",
+  "fire",
+  "snow",
+  "rain",
+  "leaf",
+  "stone"
+];
+var SessionManager = class {
+  storePath;
+  store = null;
+  constructor() {
+    this.storePath = join(homedir(), ".vibetasks", "sessions.json");
+  }
+  /**
+   * Generate a memorable session ID like "swift-fox-42"
+   */
+  generateSessionId() {
+    const adj = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
+    const noun = NOUNS[Math.floor(Math.random() * NOUNS.length)];
+    const num = Math.floor(Math.random() * 100);
+    return `${adj}-${noun}-${num}`;
+  }
+  /**
+   * Load sessions from disk
+   */
+  async load() {
+    if (this.store) return this.store;
+    try {
+      const data = await readFile(this.storePath, "utf-8");
+      this.store = JSON.parse(data);
+      return this.store;
+    } catch {
+      this.store = { sessions: [] };
+      return this.store;
+    }
+  }
+  /**
+   * Save sessions to disk
+   */
+  async save() {
+    const dir = join(homedir(), ".vibetasks");
+    await mkdir(dir, { recursive: true });
+    await writeFile(this.storePath, JSON.stringify(this.store, null, 2));
+  }
+  /**
+   * Start a new session
+   */
+  async startSession(project) {
+    const store = await this.load();
+    if (store.currentSession) {
+      await this.endSession();
+    }
+    const session = {
+      id: this.generateSessionId(),
+      fullId: randomUUID(),
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      project,
+      actions: []
+    };
+    store.sessions.push(session);
+    store.currentSession = session.id;
+    await this.save();
+    return session;
+  }
+  /**
+   * Get current session (or start one if none exists)
+   */
+  async getCurrentSession() {
+    const store = await this.load();
+    if (!store.currentSession) {
+      return null;
+    }
+    return store.sessions.find((s) => s.id === store.currentSession) || null;
+  }
+  /**
+   * Get or create current session
+   */
+  async getOrCreateSession(project) {
+    const current = await this.getCurrentSession();
+    if (current) return current;
+    return this.startSession(project);
+  }
+  /**
+   * Log an action in the current session
+   */
+  async logAction(action) {
+    const store = await this.load();
+    const session = store.sessions.find((s) => s.id === store.currentSession);
+    if (!session) {
+      const newSession = await this.startSession();
+      newSession.actions.push({
+        ...action,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } else {
+      session.actions.push({
+        ...action,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    await this.save();
+  }
+  /**
+   * End the current session
+   */
+  async endSession(summary) {
+    const store = await this.load();
+    const session = store.sessions.find((s) => s.id === store.currentSession);
+    if (session) {
+      session.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+      session.summary = summary;
+      store.currentSession = void 0;
+      await this.save();
+    }
+    return session || null;
+  }
+  /**
+   * Get a session by ID (partial match supported)
+   */
+  async getSession(id) {
+    const store = await this.load();
+    let session = store.sessions.find((s) => s.id === id);
+    if (session) return session;
+    session = store.sessions.find((s) => s.id.includes(id) || s.fullId.startsWith(id));
+    return session || null;
+  }
+  /**
+   * Get recent sessions
+   */
+  async getRecentSessions(limit = 10) {
+    const store = await this.load();
+    return store.sessions.slice(-limit).reverse();
+  }
+  /**
+   * Get session summary for handoff to next AI
+   */
+  async getSessionHandoff(sessionId) {
+    const session = await this.getSession(sessionId);
+    if (!session) {
+      return `Session "${sessionId}" not found.`;
+    }
+    const lines = [
+      `## Session: ${session.id}`,
+      `Started: ${session.startedAt}`,
+      session.endedAt ? `Ended: ${session.endedAt}` : `Status: ACTIVE`,
+      session.project ? `Project: ${session.project}` : "",
+      "",
+      `### Actions (${session.actions.length}):`
+    ];
+    for (const action of session.actions) {
+      const time = new Date(action.timestamp).toLocaleTimeString();
+      switch (action.type) {
+        case "task_created":
+          lines.push(`- [${time}] Created task: "${action.taskTitle}" (${action.taskId})`);
+          break;
+        case "task_completed":
+          lines.push(`- [${time}] Completed: "${action.taskTitle}"`);
+          break;
+        case "task_updated":
+          lines.push(`- [${time}] Updated: "${action.taskTitle}"`);
+          break;
+        case "file_modified":
+          lines.push(`- [${time}] Modified: ${action.filePath}`);
+          break;
+        case "note":
+          lines.push(`- [${time}] Note: ${action.description}`);
+          break;
+      }
+    }
+    if (session.summary) {
+      lines.push("", "### Summary:", session.summary);
+    }
+    return lines.filter(Boolean).join("\n");
+  }
+};
+var sessionManager = null;
+function getSessionManager() {
+  if (!sessionManager) {
+    sessionManager = new SessionManager();
+  }
+  return sessionManager;
+}
+
+// src/commands/add.ts
+var addCommand = new Command2("add").description("Add a new task").argument("<title>", "Task title").option("-n, --notes <notes>", "Task notes (markdown supported)").option("-d, --due <date>", 'Due date (YYYY-MM-DD, "today", "tomorrow", "+3d")').option("-p, --priority <level>", "Priority: low, medium, high", "none").option("-t, --tags <tags...>", "Tags (space-separated)").option("-s, --subtasks <subtasks...>", "Subtasks (space-separated, use quotes for multi-word)").option("--project <name>", "Override auto-detected project").option("-e, --energy <level>", "Energy required: low, medium, high").action(async (title, options) => {
   const spinner = ora3("Creating task...").start();
   try {
     const authManager = new AuthManager3();
@@ -512,6 +743,11 @@ var addCommand = new Command2("add").description("Add a new task").argument("<ti
         throw new Error(`Invalid energy level. Must be one of: ${validEnergy.join(", ")}`);
       }
     }
+    const subtasksJson = options.subtasks?.map((subtaskTitle) => ({
+      id: randomUUID2(),
+      title: subtaskTitle,
+      done: false
+    })) || [];
     const task = await taskOps.createTask({
       title,
       notes: options.notes,
@@ -524,7 +760,8 @@ var addCommand = new Command2("add").description("Add a new task").argument("<ti
       // ai or human
       status: createdBy === "ai" ? "vibing" : "todo",
       // AI tasks start vibing
-      energy_required: options.energy
+      energy_required: options.energy,
+      subtasks_json: subtasksJson
     });
     if (options.tags && options.tags.length > 0) {
       const tagIds = [];
@@ -535,6 +772,15 @@ var addCommand = new Command2("add").description("Add a new task").argument("<ti
       await taskOps.linkTaskTags(task.id, tagIds);
     }
     spinner.succeed(chalk3.green("Task created!"));
+    if (createdBy === "ai") {
+      const sessionManager2 = getSessionManager();
+      await sessionManager2.logAction({
+        type: "task_created",
+        description: `Created task: "${title}"`,
+        taskId: task.id,
+        taskTitle: title
+      });
+    }
     console.log();
     if (projectTag) {
       console.log(chalk3.gray(`\u{1F4C1} Project: ${chalk3.white(projectTag)}`));
@@ -566,6 +812,12 @@ var addCommand = new Command2("add").description("Add a new task").argument("<ti
     if (options.tags && options.tags.length > 0) {
       console.log(chalk3.magenta(`Tags: ${options.tags.join(", ")}`));
     }
+    if (subtasksJson.length > 0) {
+      console.log(chalk3.cyan(`Subtasks: ${subtasksJson.length}`));
+      subtasksJson.forEach((st, i) => {
+        console.log(chalk3.gray(`  ${i + 1}. ${st.title}`));
+      });
+    }
     console.log();
     process.exit(0);
   } catch (error) {
@@ -590,7 +842,81 @@ import { Command as Command3 } from "commander";
 import chalk4 from "chalk";
 import Table from "cli-table3";
 import { AuthManager as AuthManager4, TaskOperations as TaskOperations2 } from "@vibetasks/core";
-var listCommand = new Command3("list").description("List tasks").argument("[filter]", "Filter: all, today, upcoming, completed", "all").option("-l, --limit <number>", "Maximum number of tasks to show", "50").option("--project <name>", "Filter by project tag").option("--created-by <source>", "Filter by creator: ai or human").option("--status <status>", "Filter by status: todo, vibing, done").action(async (filter, options) => {
+
+// src/utils/short-ids.ts
+import { writeFile as writeFile2, readFile as readFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var ShortIdManager = class {
+  storePath;
+  maxIds = 99;
+  constructor() {
+    this.storePath = join2(homedir2(), ".vibetasks", "short-ids.json");
+  }
+  /**
+   * Save mappings from a list of task IDs
+   * Short IDs are assigned 1, 2, 3... based on array order
+   */
+  async saveMappings(taskIds) {
+    const mappings = taskIds.slice(0, this.maxIds).map((fullId, index) => ({
+      shortId: index + 1,
+      fullId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+    const store = {
+      mappings,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const dir = join2(homedir2(), ".vibetasks");
+    await mkdir2(dir, { recursive: true });
+    await writeFile2(this.storePath, JSON.stringify(store, null, 2));
+  }
+  /**
+   * Get the full UUID for a short ID
+   */
+  async getFullId(shortId) {
+    try {
+      const content = await readFile2(this.storePath, "utf-8");
+      const store = JSON.parse(content);
+      const mapping = store.mappings.find((m) => m.shortId === shortId);
+      return mapping?.fullId || null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get the short ID for a full UUID (if it exists in current mappings)
+   */
+  async getShortId(fullId) {
+    try {
+      const content = await readFile2(this.storePath, "utf-8");
+      const store = JSON.parse(content);
+      const mapping = store.mappings.find((m) => m.fullId === fullId);
+      return mapping?.shortId || null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Resolve an ID that could be either short (1-99) or full UUID
+   */
+  async resolveId(idOrShortId) {
+    const shortId = parseInt(idOrShortId, 10);
+    if (!isNaN(shortId) && shortId >= 1 && shortId <= this.maxIds) {
+      const fullId = await this.getFullId(shortId);
+      if (fullId) {
+        return fullId;
+      }
+      throw new Error(
+        `Short ID #${shortId} not found. Run 'vibetasks list --short-ids' first to generate mappings.`
+      );
+    }
+    return idOrShortId;
+  }
+};
+
+// src/commands/list.ts
+var listCommand = new Command3("list").description("List tasks").argument("[filter]", "Filter: all, today, upcoming, completed", "all").option("-l, --limit <number>", "Maximum number of tasks to show", "50").option("--project <name>", "Filter by project tag").option("--created-by <source>", "Filter by creator: ai or human").option("--status <status>", "Filter by status: todo, vibing, done").option("--short-ids", "Show short numeric IDs (1-99) for easy reference").action(async (filter, options) => {
   try {
     const validFilters = ["all", "today", "upcoming", "completed"];
     if (!validFilters.includes(filter)) {
@@ -634,8 +960,18 @@ ${filterMessages[filter] || "No tasks found"}.
     }
     const limit = parseInt(options.limit, 10);
     const displayTasks = tasks.slice(0, limit);
+    const shortIdManager = new ShortIdManager();
+    if (options.shortIds) {
+      await shortIdManager.saveMappings(displayTasks.map((t) => t.id));
+    }
     const table = new Table({
-      head: [
+      head: options.shortIds ? [
+        chalk4.cyan("#"),
+        chalk4.cyan("Status"),
+        chalk4.cyan("Title"),
+        chalk4.cyan("Progress"),
+        chalk4.cyan("Due")
+      ] : [
         chalk4.cyan("ID"),
         chalk4.cyan("Status"),
         chalk4.cyan("Title"),
@@ -643,10 +979,10 @@ ${filterMessages[filter] || "No tasks found"}.
         chalk4.cyan("Priority"),
         chalk4.cyan("Due")
       ],
-      colWidths: [10, 10, 35, 15, 10, 12],
+      colWidths: options.shortIds ? [5, 10, 40, 12, 12] : [10, 10, 35, 15, 10, 12],
       wordWrap: true
     });
-    displayTasks.forEach((task) => {
+    displayTasks.forEach((task, index) => {
       const priorityColors = {
         high: chalk4.red,
         medium: chalk4.yellow,
@@ -665,6 +1001,7 @@ ${filterMessages[filter] || "No tasks found"}.
       };
       const priorityColor = priorityColors[task.priority || "none"];
       const statusColor = statusColors[task.status || "todo"];
+      const shortId = chalk4.yellow.bold(`${index + 1}`);
       const id = task.id.substring(0, 8);
       const status = statusColor(`${statusEmojis[task.status || "todo"]} ${task.status || "todo"}`);
       const title = task.status === "done" ? chalk4.strikethrough(task.title) : task.title;
@@ -672,7 +1009,15 @@ ${filterMessages[filter] || "No tasks found"}.
       const project = task.project_tag ? chalk4.blue(task.project_tag) : chalk4.gray("-");
       const priority = priorityColor(task.priority || "none");
       const dueDate = task.due_date ? task.due_date.split("T")[0] : chalk4.gray("-");
-      table.push([id, status, titleWithAI, project, priority, dueDate]);
+      const subtasks = task.subtasks_json || task.subtasks || [];
+      const doneCount = subtasks.filter((s) => s.done).length;
+      const totalCount = subtasks.length;
+      const progress = totalCount > 0 ? chalk4.cyan(`${doneCount}/${totalCount}`) : chalk4.gray("-");
+      if (options.shortIds) {
+        table.push([shortId, status, titleWithAI, progress, dueDate]);
+      } else {
+        table.push([id, status, titleWithAI, project, priority, dueDate]);
+      }
     });
     console.log("\n" + table.toString());
     const filterLabels = {
@@ -686,6 +1031,10 @@ Total: ${tasks.length} ${filterLabels[filter]} task${tasks.length === 1 ? "" : "
     if (tasks.length > limit) {
       console.log(chalk4.yellow(`Showing ${limit} of ${tasks.length} tasks. Use --limit to show more.`));
     }
+    if (options.shortIds) {
+      console.log(chalk4.gray(`
+Use: vibetasks vibing <#> to start working on a task`));
+    }
     console.log();
     process.exit(0);
   } catch (error) {
@@ -706,15 +1055,16 @@ import { Command as Command4 } from "commander";
 import ora4 from "ora";
 import chalk5 from "chalk";
 import { AuthManager as AuthManager5, TaskOperations as TaskOperations3 } from "@vibetasks/core";
-var doneCommand = new Command4("done").description("Mark a task as complete").argument("<id>", "Task ID (full or first 8 characters)").action(async (id) => {
+var doneCommand = new Command4("done").description("Mark a task as complete").argument("<id>", "Task ID, short # (1-99), or first 8 characters").action(async (id) => {
   const spinner = ora4("Completing task...").start();
   try {
     const authManager = new AuthManager5();
     const taskOps = await TaskOperations3.fromAuthManager(authManager);
-    let taskId = id;
-    if (id.length < 32) {
+    const shortIdManager = new ShortIdManager();
+    let taskId = await shortIdManager.resolveId(id);
+    if (taskId.length < 32) {
       const allTasks = await taskOps.getTasks("all");
-      const matchingTask = allTasks.find((t) => t.id.startsWith(id));
+      const matchingTask = allTasks.find((t) => t.id.startsWith(taskId));
       if (!matchingTask) {
         spinner.fail(chalk5.red("Task not found"));
         console.error(chalk5.gray(`
@@ -725,6 +1075,13 @@ No task found with ID starting with: ${id}
       taskId = matchingTask.id;
     }
     const task = await taskOps.completeTask(taskId);
+    const sessionManager2 = getSessionManager();
+    await sessionManager2.logAction({
+      type: "task_completed",
+      description: `Completed: "${task.title}"`,
+      taskId: task.id,
+      taskTitle: task.title
+    });
     spinner.succeed(chalk5.green("Task completed!"));
     console.log(chalk5.gray(`
 \u2713 ${task.title}`));
@@ -752,11 +1109,16 @@ import ora5 from "ora";
 import inquirer2 from "inquirer";
 import { AuthManager as AuthManager6, TaskOperations as TaskOperations4 } from "@vibetasks/core";
 var WIP_LIMIT = 3;
-var vibingCommand = new Command5("vibing").alias("start").alias("v").description("Start working on a task (move to vibing status)").argument("[task-id]", "Task ID to start vibing on").option("-p, --pick", "Pick from todo tasks interactively").action(async (taskId, options) => {
+var vibingCommand = new Command5("vibing").alias("start").alias("v").description("Start working on a task (move to vibing status)").argument("[task-id]", "Task ID or short # (1-99) to start vibing on").option("-p, --pick", "Pick from todo tasks interactively").action(async (taskIdInput, options) => {
   const spinner = ora5();
   try {
     const authManager = new AuthManager6();
     const taskOps = await TaskOperations4.fromAuthManager(authManager);
+    const shortIdManager = new ShortIdManager();
+    let taskId;
+    if (taskIdInput) {
+      taskId = await shortIdManager.resolveId(taskIdInput);
+    }
     const allTasks = await taskOps.getTasks("all");
     const vibingTasks = allTasks.filter((t) => t.status === "vibing" && !t.completed);
     if (vibingTasks.length >= WIP_LIMIT) {
@@ -2721,10 +3083,240 @@ function getTagColor2(category) {
   return colors[category] || "#FF6B6B";
 }
 
+// src/commands/next.ts
+import { Command as Command16 } from "commander";
+import chalk17 from "chalk";
+import { AuthManager as AuthManager16, TaskOperations as TaskOperations12 } from "@vibetasks/core";
+var PRIORITY_ORDER = { high: 0, medium: 1, low: 2, none: 3 };
+var nextCommand = new Command16("next").description("Show and optionally start the highest priority task").option("-s, --start", "Start vibing on the task immediately").option("--project <name>", "Filter by project tag").action(async (options) => {
+  try {
+    const authManager = new AuthManager16();
+    const taskOps = await TaskOperations12.fromAuthManager(authManager);
+    let tasks = await taskOps.getTasks("all");
+    tasks = tasks.filter((t) => t.status !== "done" && t.status !== "archived" && !t.completed);
+    if (options.project) {
+      tasks = tasks.filter((t) => t.project_tag === options.project);
+    }
+    tasks.sort((a, b) => {
+      const priorityDiff = (PRIORITY_ORDER[a.priority || "none"] || 3) - (PRIORITY_ORDER[b.priority || "none"] || 3);
+      if (priorityDiff !== 0) return priorityDiff;
+      if (a.status === "vibing" && b.status !== "vibing") return -1;
+      if (b.status === "vibing" && a.status !== "vibing") return 1;
+      return (a.position || 0) - (b.position || 0);
+    });
+    if (tasks.length === 0) {
+      console.log(chalk17.gray("\n\u{1F389} No tasks in queue! You're all caught up.\n"));
+      process.exit(0);
+    }
+    const nextTask = tasks[0];
+    if (options.start && nextTask.status !== "vibing") {
+      await taskOps.updateTaskStatus(nextTask.id, "vibing");
+      console.log(chalk17.green(`
+\u26A1 Started vibing on task!
+`));
+    }
+    const priorityColors = {
+      high: chalk17.red,
+      medium: chalk17.yellow,
+      low: chalk17.blue,
+      none: chalk17.gray
+    };
+    const priorityEmojis = {
+      high: "\u{1F534}",
+      medium: "\u{1F7E1}",
+      low: "\u{1F535}",
+      none: "\u26AA"
+    };
+    const statusColors = {
+      todo: chalk17.gray,
+      vibing: chalk17.magenta,
+      done: chalk17.green
+    };
+    const priority = nextTask.priority || "none";
+    const priorityColor = priorityColors[priority];
+    const priorityEmoji = priorityEmojis[priority];
+    const statusColor = statusColors[nextTask.status || "todo"];
+    const shortIdManager = new ShortIdManager();
+    await shortIdManager.saveMappings([nextTask.id]);
+    console.log("\n" + chalk17.bold("\u2501".repeat(50)));
+    console.log(chalk17.bold.cyan("\n\u{1F4CD} NEXT UP:\n"));
+    console.log(chalk17.bold.white(`   ${nextTask.title}`));
+    console.log();
+    console.log(`   ${priorityEmoji} Priority: ${priorityColor(priority.charAt(0).toUpperCase() + priority.slice(1))}`);
+    console.log(`   \u{1F4CA} Status: ${statusColor(nextTask.status || "todo")}`);
+    if (nextTask.project_tag) {
+      console.log(`   \u{1F4C1} Project: ${chalk17.blue(nextTask.project_tag)}`);
+    }
+    if (nextTask.due_date) {
+      const dueDate = new Date(nextTask.due_date);
+      const today = /* @__PURE__ */ new Date();
+      const isOverdue = dueDate < today;
+      const dateStr = nextTask.due_date.split("T")[0];
+      console.log(`   \u{1F4C5} Due: ${isOverdue ? chalk17.red(dateStr + " (OVERDUE)") : chalk17.gray(dateStr)}`);
+    }
+    if (nextTask.context_notes) {
+      console.log(`
+   ${chalk17.blue("\u{1F4AC} Context:")}`);
+      console.log(chalk17.gray(`   ${nextTask.context_notes}`));
+    }
+    const subtasks = nextTask.subtasks_json || nextTask.subtasks || [];
+    if (subtasks.length > 0) {
+      const doneCount = subtasks.filter((s) => s.done).length;
+      console.log(`
+   ${chalk17.cyan("\u2713 Subtasks:")} ${doneCount}/${subtasks.length} done`);
+      subtasks.slice(0, 5).forEach((s) => {
+        const icon = s.done ? chalk17.green("\u2713") : chalk17.gray("\u25CB");
+        const text = s.done ? chalk17.strikethrough.gray(s.title) : s.title;
+        console.log(`     ${icon} ${text}`);
+      });
+      if (subtasks.length > 5) {
+        console.log(chalk17.gray(`     ... and ${subtasks.length - 5} more`));
+      }
+    }
+    console.log("\n" + chalk17.bold("\u2501".repeat(50)));
+    console.log(chalk17.gray("\n  Quick actions:"));
+    if (nextTask.status !== "vibing") {
+      console.log(chalk17.gray(`  \u2022 ${chalk17.cyan("vibetasks next --start")} - Start vibing on this task`));
+    }
+    console.log(chalk17.gray(`  \u2022 ${chalk17.cyan("vibetasks vibing 1")} - Start working (short ID #1)`));
+    console.log(chalk17.gray(`  \u2022 ${chalk17.cyan("vibetasks done 1")} - Mark as done`));
+    console.log();
+    process.exit(0);
+  } catch (error) {
+    if (error.message.includes("Not authenticated")) {
+      console.error(chalk17.yellow("\n\u26A0\uFE0F  You need to login first"));
+      console.error(chalk17.gray("Run: vibetasks login\n"));
+    } else {
+      console.error(chalk17.red(`
+Error: ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/session.ts
+import { Command as Command17 } from "commander";
+import chalk18 from "chalk";
+import { detectProject as detectProject5 } from "@vibetasks/shared/utils/project-detector";
+var sessionCommand = new Command17("session").description("Manage AI sessions for crash recovery and handoffs").addCommand(
+  new Command17("start").description("Start a new session").action(async () => {
+    const sessionManager2 = getSessionManager();
+    const project = await detectProject5();
+    const session = await sessionManager2.startSession(project?.name);
+    console.log(chalk18.green("\u2713 Session started"));
+    console.log();
+    console.log(chalk18.cyan("Session ID:"), chalk18.bold(session.id));
+    console.log(chalk18.gray("Full ID:"), session.fullId.slice(0, 8));
+    if (session.project) {
+      console.log(chalk18.gray("Project:"), session.project);
+    }
+    console.log();
+    console.log(chalk18.yellow("Tip:"), "If the AI crashes, tell the next one:");
+    console.log(chalk18.white(`  "Continue from session ${session.id}"`));
+  })
+).addCommand(
+  new Command17("current").alias("status").description("Show current session status").action(async () => {
+    const sessionManager2 = getSessionManager();
+    const session = await sessionManager2.getCurrentSession();
+    if (!session) {
+      console.log(chalk18.yellow("No active session"));
+      console.log(chalk18.gray("Start one with: vibetasks session start"));
+      return;
+    }
+    console.log(chalk18.cyan("Current Session:"), chalk18.bold(session.id));
+    console.log(chalk18.gray("Started:"), new Date(session.startedAt).toLocaleString());
+    if (session.project) {
+      console.log(chalk18.gray("Project:"), session.project);
+    }
+    console.log(chalk18.gray("Actions:"), session.actions.length);
+    console.log();
+    if (session.actions.length > 0) {
+      console.log(chalk18.cyan("Recent actions:"));
+      const recent = session.actions.slice(-5);
+      for (const action of recent) {
+        const time = new Date(action.timestamp).toLocaleTimeString();
+        const icon = {
+          task_created: "\u2795",
+          task_completed: "\u2713",
+          task_updated: "\u{1F4DD}",
+          file_modified: "\u{1F4C4}",
+          note: "\u{1F4AC}"
+        }[action.type];
+        console.log(chalk18.gray(`  ${icon} [${time}]`), action.description);
+      }
+      if (session.actions.length > 5) {
+        console.log(chalk18.gray(`  ... and ${session.actions.length - 5} more`));
+      }
+    }
+  })
+).addCommand(
+  new Command17("end").description("End the current session").option("-s, --summary <text>", "Add a summary of what was done").action(async (options) => {
+    const sessionManager2 = getSessionManager();
+    const session = await sessionManager2.endSession(options.summary);
+    if (!session) {
+      console.log(chalk18.yellow("No active session to end"));
+      return;
+    }
+    console.log(chalk18.green("\u2713 Session ended:"), chalk18.bold(session.id));
+    console.log(chalk18.gray("Duration:"), formatDuration(session.startedAt, session.endedAt));
+    console.log(chalk18.gray("Actions:"), session.actions.length);
+    if (options.summary) {
+      console.log(chalk18.gray("Summary:"), options.summary);
+    }
+  })
+).addCommand(
+  new Command17("list").description("List recent sessions").option("-n, --limit <number>", "Number of sessions to show", "10").action(async (options) => {
+    const sessionManager2 = getSessionManager();
+    const sessions = await sessionManager2.getRecentSessions(parseInt(options.limit));
+    if (sessions.length === 0) {
+      console.log(chalk18.yellow("No sessions found"));
+      return;
+    }
+    console.log(chalk18.cyan("Recent Sessions:"));
+    console.log();
+    for (const session of sessions) {
+      const status = session.endedAt ? chalk18.gray("ended") : chalk18.green("active");
+      const date = new Date(session.startedAt).toLocaleDateString();
+      const actions = session.actions.length;
+      console.log(
+        chalk18.bold(session.id),
+        status,
+        chalk18.gray(`| ${date} | ${actions} actions`),
+        session.project ? chalk18.blue(`[${session.project}]`) : ""
+      );
+    }
+  })
+).addCommand(
+  new Command17("show").alias("handoff").description("Show session details for handoff to next AI").argument("<session-id>", "Session ID (partial match supported)").action(async (sessionId) => {
+    const sessionManager2 = getSessionManager();
+    const handoff = await sessionManager2.getSessionHandoff(sessionId);
+    console.log(handoff);
+  })
+).addCommand(
+  new Command17("log").description("Log an action or note to the current session").argument("<message>", "Note to log").action(async (message) => {
+    const sessionManager2 = getSessionManager();
+    await sessionManager2.logAction({
+      type: "note",
+      description: message
+    });
+    console.log(chalk18.green("\u2713 Logged to session"));
+  })
+);
+function formatDuration(start, end) {
+  const ms = new Date(end).getTime() - new Date(start).getTime();
+  const minutes = Math.floor(ms / 6e4);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`;
+  }
+  return `${minutes}m`;
+}
+
 // bin/vibetasks.ts
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../../package.json");
-var program = new Command16();
+var program = new Command18();
 program.name("vibetasks").description("VibeTasks CLI - Fast task management for vibers").version(pkg.version);
 program.addCommand(setupCommand);
 program.addCommand(loginCommand);
@@ -2742,4 +3334,6 @@ program.addCommand(watchCommand);
 program.addCommand(checkCommand);
 program.addCommand(archiveCommand);
 program.addCommand(daemonCommand);
+program.addCommand(nextCommand);
+program.addCommand(sessionCommand);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibetasks/cli",
-  "version": "0.4.6",
+  "version": "0.5.0",
   "description": "VibeTasks CLI - Lightning-fast task management from your terminal. Works with Claude Code, Cursor, and all AI coding tools.",
   "author": "Vyas",
   "license": "MIT",
@@ -45,8 +45,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@vibetasks/core": "^0.4.2",
-    "@vibetasks/shared": "^1.1.3",
+    "@vibetasks/core": "^0.5.0",
+    "@vibetasks/shared": "^1.2.0",
     "commander": "^11.1.0",
     "chalk": "^5.3.0",
     "ora": "^8.0.1",