@vibetasks/cli 0.6.9 → 0.6.11

package/dist/bin/vibetasks.js

@@ -11,7 +11,7 @@ import {
 } from "../chunk-2KRLRG4G.js";
 
 // bin/vibetasks.ts
-import { Command as Command21 } from "commander";
+import { Command as Command30 } from "commander";
 import { createRequire } from "module";
 
 // src/commands/login.ts
@@ -368,7 +368,7 @@ var loginCommand = new Command("login").description("Authenticate with VibeTasks
 import { Command as Command2 } from "commander";
 import ora2 from "ora";
 import chalk3 from "chalk";
-import { AuthManager as AuthManager2, TaskOperations } from "@vibetasks/core";
+import { AuthManager as AuthManager3, TaskOperations } from "@vibetasks/core";
 
 // src/utils/date-parser.ts
 import { addDays, addWeeks, addMonths, format, parse, isValid } from "date-fns";
@@ -416,6 +416,7 @@ import { writeFile, readFile, mkdir } from "fs/promises";
 import { join } from "path";
 import { homedir } from "os";
 import { randomUUID } from "crypto";
+import { AuthManager as AuthManager2 } from "@vibetasks/core";
 var ADJECTIVES = [
   "swift",
   "calm",
@@ -455,8 +456,102 @@ var NOUNS = [
 var SessionManager = class {
   storePath;
   store = null;
+  authManager;
   constructor() {
     this.storePath = join(homedir(), ".vibetasks", "sessions.json");
+    this.authManager = new AuthManager2();
+  }
+  /**
+   * Get the API base URL for syncing sessions
+   */
+  getApiBaseUrl() {
+    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";
+  }
+  /**
+   * Sync a single action to the server in real-time
+   * Called after each action is logged locally
+   */
+  async syncActionToServer(sessionId, action) {
+    try {
+      const token = await this.authManager.getValidAccessToken();
+      if (!token) {
+        return false;
+      }
+      const apiUrl = `${this.getApiBaseUrl()}/api/sessions/${sessionId}`;
+      const payload = {
+        action_type: action.type,
+        description: action.description,
+        timestamp: action.timestamp,
+        task_id: action.taskId
+      };
+      const response = await fetch(apiUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${token}`
+        },
+        body: JSON.stringify(payload)
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Sync a session to the server database
+   * Called automatically when a session ends
+   */
+  async syncToServer(session) {
+    try {
+      const token = await this.authManager.getValidAccessToken();
+      if (!token) {
+        return false;
+      }
+      const apiUrl = `${this.getApiBaseUrl()}/api/sessions`;
+      const payload = {
+        session_id: session.id,
+        status: session.endedAt ? "ended" : "active",
+        started_at: session.startedAt,
+        ended_at: session.endedAt,
+        project_tag: session.project,
+        summary: session.summary,
+        handoff_notes: session.summary,
+        // Use summary as handoff notes
+        actions: session.actions.map((action) => ({
+          action_type: action.type,
+          description: action.description,
+          timestamp: action.timestamp,
+          task_id: action.taskId
+        }))
+      };
+      const response = await fetch(apiUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${token}`
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        if (process.stderr.isTTY) {
+          console.error(`Session sync failed: ${error}`);
+        }
+        return false;
+      }
+      return true;
+    } catch (error) {
+      if (process.stderr.isTTY) {
+        console.error(`Session sync error: ${error.message}`);
+      }
+      return false;
+    }
   }
   /**
    * Generate a memorable session ID like "swift-fox-42"
@@ -510,6 +605,8 @@ var SessionManager = class {
     store.sessions.push(session);
     store.currentSession = session.id;
     await this.save();
+    await this.syncToServer(session).catch(() => {
+    });
     return session;
   }
   /**
@@ -532,23 +629,22 @@ var SessionManager = class {
   }
   /**
    * Log an action in the current session
+   * Syncs to server in real-time (non-blocking)
    */
   async logAction(action) {
     const store = await this.load();
-    const session = store.sessions.find((s) => s.id === store.currentSession);
+    let session = store.sessions.find((s) => s.id === store.currentSession);
+    const actionWithTimestamp = {
+      ...action,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
     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()
-      });
+      session = await this.startSession();
     }
+    session.actions.push(actionWithTimestamp);
     await this.save();
+    this.syncActionToServer(session.id, actionWithTimestamp).catch(() => {
+    });
   }
   /**
    * End the current session
@@ -561,6 +657,8 @@ var SessionManager = class {
       session.summary = summary;
       store.currentSession = void 0;
       await this.save();
+      this.syncToServer(session).catch(() => {
+      });
     }
     return session || null;
   }
@@ -622,6 +720,58 @@ var SessionManager = class {
     }
     return lines.filter(Boolean).join("\n");
   }
+  /**
+   * Generate a comprehensive handoff for the next AI
+   * Includes: vibing tasks with context, git status, files changed, next steps
+   */
+  async generateHandoff() {
+    const { execSync: execSync2 } = await import("child_process");
+    const lines = [];
+    lines.push("# AI Handoff");
+    lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}`);
+    lines.push("");
+    const currentSession = await this.getCurrentSession();
+    if (currentSession) {
+      lines.push(`## Current Session: ${currentSession.id}`);
+      lines.push(`Project: ${currentSession.project || "unknown"}`);
+      lines.push(`Started: ${new Date(currentSession.startedAt).toLocaleString()}`);
+      lines.push(`Actions: ${currentSession.actions.length}`);
+      lines.push("");
+    }
+    try {
+      const gitStatus = execSync2("git status --porcelain", { encoding: "utf-8", timeout: 5e3 }).trim();
+      if (gitStatus) {
+        const changedFiles = gitStatus.split("\n").slice(0, 20);
+        lines.push("## Uncommitted Changes");
+        changedFiles.forEach((f) => lines.push(`- ${f}`));
+        if (gitStatus.split("\n").length > 20) {
+          lines.push(`- ... and ${gitStatus.split("\n").length - 20} more files`);
+        }
+        lines.push("");
+      }
+    } catch {
+    }
+    try {
+      const recentCommits = execSync2("git log --oneline -3", { encoding: "utf-8", timeout: 5e3 }).trim();
+      if (recentCommits) {
+        lines.push("## Recent Commits");
+        recentCommits.split("\n").forEach((c) => lines.push(`- ${c}`));
+        lines.push("");
+      }
+    } catch {
+    }
+    lines.push("---");
+    lines.push("## For Next AI");
+    lines.push("");
+    lines.push("1. Check vibing tasks: `vibetasks list --status vibing --short-ids`");
+    lines.push('2. Read context_notes on vibing tasks for "where I left off"');
+    lines.push("3. Check git status for uncommitted work");
+    lines.push("");
+    if (currentSession) {
+      lines.push(`To continue this session's work: "Continue from session ${currentSession.id}"`);
+    }
+    return lines.join("\n");
+  }
 };
 var sessionManager = null;
 function getSessionManager() {
@@ -631,11 +781,84 @@ function getSessionManager() {
   return sessionManager;
 }
 
+// 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 tasks with their short_ids
+   * Uses the stable short_id from the database
+   */
+  async saveMappings(tasks) {
+    const mappings = tasks.filter((t) => t.short_id).slice(0, this.maxIds).map((task, index) => ({
+      shortId: task.short_id,
+      // Use actual short_id from database
+      fullId: task.id,
+      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/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) => {
+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").option("-a, --acceptance <criteria...>", 'Acceptance criteria - "DONE WHEN" conditions (use quotes for multi-word)').option("-f, --files <files...>", "Relevant files for this task").option("--non-goals <goals...>", "Explicit non-goals / out of scope items").action(async (title, options) => {
   const spinner = ora2("Creating task...").start();
   try {
-    const authManager = new AuthManager2();
+    const authManager = new AuthManager3();
     const taskOps = await TaskOperations.fromAuthManager(authManager);
     let projectTag;
     if (options.project) {
@@ -675,14 +898,21 @@ var addCommand = new Command2("add").description("Add a new task").argument("<ti
       title: subtaskTitle,
       done: false
     })) || [];
+    const acceptanceCriteria = options.acceptance?.map((text) => ({
+      id: randomUUID2(),
+      text,
+      done: false
+    })) || [];
+    const relevantFiles = options.files || [];
+    const nonGoals = options.nonGoals || [];
     let sessionId;
     let sessionHistory = [];
-    if (createdBy === "ai") {
-      const sessionManager2 = getSessionManager();
-      const session = await sessionManager2.getOrCreateSession(projectTag);
-      sessionId = session.id;
+    const sessionManager2 = getSessionManager();
+    const currentSession = await sessionManager2.getCurrentSession();
+    if (currentSession) {
+      sessionId = currentSession.id;
       sessionHistory = [{
-        session_id: session.id,
+        session_id: currentSession.id,
         action: "created",
         at: (/* @__PURE__ */ new Date()).toISOString()
       }];
@@ -703,8 +933,12 @@ var addCommand = new Command2("add").description("Add a new task").argument("<ti
       subtasks_json: subtasksJson,
       session_id: sessionId,
       // Current AI session
-      session_history: sessionHistory
+      session_history: sessionHistory,
       // Full history of sessions
+      // New AI-assisted planning fields
+      acceptance_criteria: acceptanceCriteria.length > 0 ? acceptanceCriteria : void 0,
+      relevant_files: relevantFiles.length > 0 ? relevantFiles : void 0,
+      non_goals: nonGoals.length > 0 ? nonGoals : void 0
     });
     if (options.tags && options.tags.length > 0) {
       const tagIds = [];
@@ -715,8 +949,13 @@ 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();
+    try {
+      const shortIdManager = new ShortIdManager();
+      const allTasks = await taskOps.getTasks("all");
+      await shortIdManager.saveMappings(allTasks);
+    } catch (e) {
+    }
+    if (currentSession) {
       await sessionManager2.logAction({
         type: "task_created",
         description: `Created task: "${title}"`,
@@ -761,6 +1000,18 @@ var addCommand = new Command2("add").description("Add a new task").argument("<ti
         console.log(chalk3.gray(`  ${i + 1}. ${st.title}`));
       });
     }
+    if (acceptanceCriteria.length > 0) {
+      console.log(chalk3.cyan(`Done when:`));
+      acceptanceCriteria.forEach((ac, i) => {
+        console.log(chalk3.gray(`  - ${ac.text}`));
+      });
+    }
+    if (relevantFiles.length > 0) {
+      console.log(chalk3.yellow(`Files: ${relevantFiles.join(", ")}`));
+    }
+    if (nonGoals.length > 0) {
+      console.log(chalk3.gray(`Not in scope: ${nonGoals.join(", ")}`));
+    }
     console.log();
     process.exit(0);
   } catch (error) {
@@ -784,82 +1035,7 @@ function isRunningInClaudeCode() {
 import { Command as Command3 } from "commander";
 import chalk4 from "chalk";
 import Table from "cli-table3";
-import { AuthManager as AuthManager3, TaskOperations as TaskOperations2 } from "@vibetasks/core";
-
-// 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 tasks with their short_ids
-   * Uses the stable short_id from the database
-   */
-  async saveMappings(tasks) {
-    const mappings = tasks.filter((t) => t.short_id).slice(0, this.maxIds).map((task, index) => ({
-      shortId: task.short_id,
-      // Use actual short_id from database
-      fullId: task.id,
-      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
+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").option("--session [id]", "Filter by session (current session if no ID given)").option("--my-session", "Only show tasks from current AI session").option("--short-ids", "Show short numeric IDs (1-99) for easy reference").action(async (filter, options) => {
   try {
     const validFilters = ["all", "today", "upcoming", "completed"];
@@ -868,7 +1044,7 @@ var listCommand = new Command3("list").description("List tasks").argument("[filt
       console.error(chalk4.gray(`Valid filters: ${validFilters.join(", ")}`));
       process.exit(1);
     }
-    const authManager = new AuthManager3();
+    const authManager = new AuthManager4();
     const taskOps = await TaskOperations2.fromAuthManager(authManager);
     let tasks = await taskOps.getTasks(filter);
     if (options.project) {
@@ -1031,11 +1207,11 @@ Error: ${error.message}
 import { Command as Command4 } from "commander";
 import ora3 from "ora";
 import chalk5 from "chalk";
-import { AuthManager as AuthManager4, TaskOperations as TaskOperations3 } from "@vibetasks/core";
+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, short # (1-99), or first 8 characters").option("-n, --notes <notes>", "Completion notes - what was done, any final notes").option("-c, --context <context>", "Context notes (alias for --notes)").action(async (id, options) => {
   const spinner = ora3("Completing task...").start();
   try {
-    const authManager = new AuthManager4();
+    const authManager = new AuthManager5();
     const taskOps = await TaskOperations3.fromAuthManager(authManager);
     const shortIdManager = new ShortIdManager();
     let taskId = await shortIdManager.resolveId(id);
@@ -1108,11 +1284,11 @@ import { Command as Command5 } from "commander";
 import chalk6 from "chalk";
 import ora4 from "ora";
 import inquirer from "inquirer";
-import { AuthManager as AuthManager5, TaskOperations as TaskOperations4 } from "@vibetasks/core";
+import { AuthManager as AuthManager6, TaskOperations as TaskOperations4 } from "@vibetasks/core";
 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 = ora4();
   try {
-    const authManager = new AuthManager5();
+    const authManager = new AuthManager6();
     const taskOps = await TaskOperations4.fromAuthManager(authManager);
     const shortIdManager = new ShortIdManager();
     let taskId;
@@ -1190,10 +1366,10 @@ var vibingCommand = new Command5("vibing").alias("start").alias("v").description
 import { Command as Command6 } from "commander";
 import chalk7 from "chalk";
 import Table2 from "cli-table3";
-import { AuthManager as AuthManager6, TaskOperations as TaskOperations5 } from "@vibetasks/core";
+import { AuthManager as AuthManager7, TaskOperations as TaskOperations5 } from "@vibetasks/core";
 var searchCommand = new Command6("search").description("Search tasks by title").argument("<query>", "Search query").option("-l, --limit <number>", "Maximum number of results", "20").action(async (query, options) => {
   try {
-    const authManager = new AuthManager6();
+    const authManager = new AuthManager7();
     const taskOps = await TaskOperations5.fromAuthManager(authManager);
     const limit = parseInt(options.limit, 10);
     const tasks = await taskOps.searchTasks(query, limit);
@@ -1250,7 +1426,7 @@ Error: ${error.message}
 import { Command as Command7 } from "commander";
 import ora5 from "ora";
 import chalk8 from "chalk";
-import { AuthManager as AuthManager7, TaskOperations as TaskOperations6 } from "@vibetasks/core";
+import { AuthManager as AuthManager8, TaskOperations as TaskOperations6 } from "@vibetasks/core";
 var updateCommand = new Command7("update").description("Update a task").argument("<id>", "Task ID (full or first 8 characters)").option("-t, --title <title>", "New title").option("-n, --notes <notes>", "New notes").option("-d, --due <date>", "New due date").option("-p, --priority <level>", "New priority: low, medium, high, none").option("-s, --status <status>", "New status: todo, vibing, done").option("--project <name>", "New project tag").option("-e, --energy <level>", "Energy required: low, medium, high").option("-c, --context <notes>", "Update context notes").action(async (id, options) => {
   if (!options.title && !options.notes && !options.due && !options.priority && !options.status && !options.project && !options.energy && !options.context) {
     console.error(chalk8.red("\nError: No updates specified"));
@@ -1259,7 +1435,7 @@ var updateCommand = new Command7("update").description("Update a task").argument
   }
   const spinner = ora5("Updating task...").start();
   try {
-    const authManager = new AuthManager7();
+    const authManager = new AuthManager8();
     const taskOps = await TaskOperations6.fromAuthManager(authManager);
     let taskId = id;
     if (id.length < 32) {
@@ -1326,10 +1502,10 @@ import { Command as Command8 } from "commander";
 import ora6 from "ora";
 import chalk9 from "chalk";
 import inquirer2 from "inquirer";
-import { AuthManager as AuthManager8, TaskOperations as TaskOperations7 } from "@vibetasks/core";
+import { AuthManager as AuthManager9, TaskOperations as TaskOperations7 } from "@vibetasks/core";
 var deleteCommand = new Command8("delete").description("Delete a task").argument("<id>", "Task ID (full or first 8 characters)").option("-y, --yes", "Skip confirmation").action(async (id, options) => {
   try {
-    const authManager = new AuthManager8();
+    const authManager = new AuthManager9();
     const taskOps = await TaskOperations7.fromAuthManager(authManager);
     let taskId = id;
     let taskTitle = "";
@@ -1385,10 +1561,10 @@ var deleteCommand = new Command8("delete").description("Delete a task").argument
 // src/commands/config.ts
 import { Command as Command9 } from "commander";
 import chalk10 from "chalk";
-import { AuthManager as AuthManager9 } from "@vibetasks/core";
+import { AuthManager as AuthManager10 } from "@vibetasks/core";
 var configCommand = new Command9("config").description("View or set configuration").argument("[key]", "Configuration key").argument("[value]", "Configuration value").action(async (key, value) => {
   try {
-    const authManager = new AuthManager9();
+    const authManager = new AuthManager10();
     if (!key) {
       const configManager = authManager["configManager"];
       const config = await configManager.getConfig();
@@ -1622,12 +1798,12 @@ import { Command as Command11 } from "commander";
 import inquirer3 from "inquirer";
 import ora8 from "ora";
 import chalk12 from "chalk";
-import { AuthManager as AuthManager10 } from "@vibetasks/core";
+import { AuthManager as AuthManager11 } from "@vibetasks/core";
 import { detectProject as detectProject2 } from "@vibetasks/shared/utils/project-detector";
 var initCommand = new Command11("init").description("Initialize TaskFlow for current project (auto-detect from git)").option("--name <name>", "Manually specify project name").action(async (options) => {
   const spinner = ora8("Detecting project...").start();
   try {
-    const authManager = new AuthManager10();
+    const authManager = new AuthManager11();
     const cwd = process.cwd();
     let project;
     if (options.name) {
@@ -1692,7 +1868,7 @@ import os from "os";
 import { createServer as createServer2 } from "http";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { AuthManager as AuthManager11, TaskOperations as TaskOperations8, createSupabaseClient } from "@vibetasks/core";
+import { AuthManager as AuthManager12, TaskOperations as TaskOperations8, createSupabaseClient } from "@vibetasks/core";
 import { detectProject as detectProject3 } from "@vibetasks/shared/utils/project-detector";
 var execAsync2 = promisify2(exec2);
 var SUPABASE_URL = "https://ihmayqzxqyednchbezya.supabase.co";
@@ -1757,7 +1933,7 @@ function showWelcome() {
 }
 async function checkExistingAuth() {
   try {
-    const authManager = new AuthManager11();
+    const authManager = new AuthManager12();
     const token = await authManager.getAccessToken();
     if (!token) return { authenticated: false };
     const supabaseUrl = await authManager.getConfig("supabase_url") || SUPABASE_URL;
@@ -1801,7 +1977,7 @@ async function runBrowserAuth() {
           return;
         }
         try {
-          const authManager = new AuthManager11();
+          const authManager = new AuthManager12();
           await authManager.setAccessToken(accessToken);
           await authManager.setRefreshToken(refreshToken);
           if (supabaseUrl) await authManager.setConfig("supabase_url", supabaseUrl);
@@ -1894,7 +2070,7 @@ async function stepAuthentication() {
     ]);
     const spinner = ora9("Authenticating...").start();
     try {
-      const authManager = new AuthManager11();
+      const authManager = new AuthManager12();
       await authManager.setConfig("supabase_url", SUPABASE_URL);
       await authManager.setConfig("supabase_key", SUPABASE_ANON_KEY);
       const supabase = createSupabaseClient({
@@ -2043,7 +2219,7 @@ async function stepProjectInit() {
     return { success: true, skipped: true };
   }
   try {
-    const authManager = new AuthManager11();
+    const authManager = new AuthManager12();
     await authManager.setConfig(`project_${process.cwd()}`, project.name);
     console.log(chalk13.green("\n  \u2713") + chalk13.white(` Project "${project.name}" configured`));
     return { success: true, projectName: project.name };
@@ -2060,7 +2236,7 @@ async function stepVerify() {
   };
   const supabaseSpinner = ora9("Testing Supabase connection...").start();
   try {
-    const authManager = new AuthManager11();
+    const authManager = new AuthManager12();
     const taskOps = await TaskOperations8.fromAuthManager(authManager);
     const tasks = await taskOps.getTasks("all");
     result.supabaseConnected = true;
@@ -2233,7 +2409,7 @@ async function runNonInteractiveSetup() {
   if (authResult.success) {
     console.log(chalk13.gray("\nVerifying connection..."));
     try {
-      const authManager = new AuthManager11();
+      const authManager = new AuthManager12();
       const taskOps = await TaskOperations8.fromAuthManager(authManager);
       const tasks = await taskOps.getTasks("all");
       console.log(chalk13.green("\u2713") + ` Connected (${tasks.length} tasks)`);
@@ -2304,7 +2480,7 @@ import { Command as Command13 } from "commander";
 import chalk14 from "chalk";
 import ora10 from "ora";
 import inquirer5 from "inquirer";
-import { AuthManager as AuthManager12, TaskOperations as TaskOperations9 } from "@vibetasks/core";
+import { AuthManager as AuthManager13, TaskOperations as TaskOperations9 } from "@vibetasks/core";
 import { detectProject as detectProject4 } from "@vibetasks/shared/utils/project-detector";
 import { generateErrorTaskTitle } from "@vibetasks/shared";
 var watchCommand = new Command13("watch").description("Monitor clipboard for errors and offer to capture them as tasks").option("-i, --interval <ms>", "Polling interval in milliseconds", "1000").option("-a, --auto", "Auto-create tasks without prompting").option("-q, --quiet", "Minimal output (only show errors)").option("--project <name>", "Override auto-detected project").action(async (options) => {
@@ -2318,7 +2494,7 @@ var watchCommand = new Command13("watch").description("Monitor clipboard for err
   let authManager;
   let taskOps;
   try {
-    authManager = new AuthManager12();
+    authManager = new AuthManager13();
     taskOps = await TaskOperations9.fromAuthManager(authManager);
   } catch (error) {
     if (error.message.includes("Not authenticated")) {
@@ -2528,11 +2704,11 @@ import { Command as Command14 } from "commander";
 import chalk15 from "chalk";
 import ora11 from "ora";
 import inquirer6 from "inquirer";
-import { AuthManager as AuthManager13, TaskOperations as TaskOperations10 } from "@vibetasks/core";
+import { AuthManager as AuthManager14, TaskOperations as TaskOperations10 } from "@vibetasks/core";
 var archiveCommand = new Command14("archive").description("Archive a task or manage archived tasks").argument("[task-id]", "Task ID to archive (full or first 8 characters)").option("-l, --list", "List all archived tasks").option("-u, --unarchive <id>", "Unarchive a task by ID").option("--pick", "Pick from completed tasks to archive").action(async (taskId, options) => {
   const spinner = ora11();
   try {
-    const authManager = new AuthManager13();
+    const authManager = new AuthManager14();
     const taskOps = await TaskOperations10.fromAuthManager(authManager);
     if (options.list) {
       spinner.start("Fetching archived tasks...");
@@ -2647,7 +2823,7 @@ import ora12 from "ora";
 import { spawn } from "child_process";
 import path3 from "path";
 import { fileURLToPath } from "url";
-import { AuthManager as AuthManager14, TaskOperations as TaskOperations11 } from "@vibetasks/core";
+import { AuthManager as AuthManager15, TaskOperations as TaskOperations11 } from "@vibetasks/core";
 import { generateErrorTaskTitle as generateErrorTaskTitle2 } from "@vibetasks/shared";
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = path3.dirname(__filename2);
@@ -2971,7 +3147,7 @@ async function showNotification(title, message, type = "info", duration) {
 async function createTaskFromError2(error) {
   const spinner = ora12("Creating task from error...").start();
   try {
-    const authManager = new AuthManager14();
+    const authManager = new AuthManager15();
     const taskOps = await TaskOperations11.fromAuthManager(authManager);
     const title = generateErrorTaskTitle2(error);
     const notes = formatErrorForNotes(error);
@@ -3034,11 +3210,11 @@ function getTagColor2(category) {
 // src/commands/next.ts
 import { Command as Command16 } from "commander";
 import chalk17 from "chalk";
-import { AuthManager as AuthManager15, TaskOperations as TaskOperations12 } from "@vibetasks/core";
+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 AuthManager15();
+    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);
@@ -3199,7 +3375,7 @@ var sessionCommand = new Command17("session").description("Manage AI sessions fo
     }
   })
 ).addCommand(
-  new Command17("end").description("End the current session").option("-s, --summary <text>", "Add a summary of what was done").action(async (options) => {
+  new Command17("end").description("End the current session").option("-s, --summary <text>", "Add a summary of what was done").option("--no-stats", "Skip showing session statistics").action(async (options) => {
     const sessionManager2 = getSessionManager();
     const session = await sessionManager2.endSession(options.summary);
     if (!session) {
@@ -3207,18 +3383,59 @@ var sessionCommand = new Command17("session").description("Manage AI sessions fo
       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"));
+    console.log();
+    if (options.stats !== false) {
+      const duration = formatDuration(session.startedAt, session.endedAt);
+      const tasksCreated = session.actions.filter((a) => a.type === "task_created").length;
+      const tasksCompleted = session.actions.filter((a) => a.type === "task_completed").length;
+      const tasksUpdated = session.actions.filter((a) => a.type === "task_updated").length;
+      const filesModified = session.actions.filter((a) => a.type === "file_modified").length;
+      const notes = session.actions.filter((a) => a.type === "note").length;
+      console.log(chalk18.cyan("\u{1F4CA} Session Statistics"));
+      console.log(chalk18.gray("\u2500".repeat(40)));
+      console.log(chalk18.white(`  Duration:        ${chalk18.bold(duration)}`));
+      console.log(chalk18.white(`  Actions logged:  ${chalk18.bold(session.actions.length.toString())}`));
+      console.log();
+      if (tasksCreated > 0 || tasksCompleted > 0 || tasksUpdated > 0) {
+        console.log(chalk18.cyan("  Tasks:"));
+        if (tasksCreated > 0) {
+          console.log(chalk18.green(`    \u2795 Created:    ${tasksCreated}`));
+        }
+        if (tasksCompleted > 0) {
+          console.log(chalk18.green(`    \u2713  Completed:  ${tasksCompleted}`));
+        }
+        if (tasksUpdated > 0) {
+          console.log(chalk18.blue(`    \u{1F4DD} Updated:    ${tasksUpdated}`));
+        }
+      }
+      if (filesModified > 0) {
+        console.log(chalk18.yellow(`  \u{1F4C4} Files modified: ${filesModified}`));
+      }
+      if (notes > 0) {
+        console.log(chalk18.gray(`  \u{1F4AC} Notes logged:   ${notes}`));
+      }
+      console.log(chalk18.gray("\u2500".repeat(40)));
+      console.log();
+    }
+    if (options.summary) {
+      console.log(chalk18.cyan("Summary:"), options.summary);
+      console.log();
+    }
+    const totalTasks = session.actions.filter(
+      (a) => a.type === "task_created" || a.type === "task_completed"
+    ).length;
+    if (totalTasks === 0) {
+      console.log(chalk18.yellow("\u{1F4A1} Tip: Use `vibetasks add` and `vibetasks done` to track work"));
+    } else if (totalTasks >= 5) {
+      console.log(chalk18.green("\u{1F525} Productive session!"));
+    }
+  })
+).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:"));
@@ -3236,7 +3453,7 @@ var sessionCommand = new Command17("session").description("Manage AI sessions fo
     }
   })
 ).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) => {
+  new Command17("show").description("Show session details").argument("<session-id>", "Session ID (partial match supported)").action(async (sessionId) => {
     const sessionManager2 = getSessionManager();
     const handoff = await sessionManager2.getSessionHandoff(sessionId);
     console.log(handoff);
@@ -3250,6 +3467,23 @@ var sessionCommand = new Command17("session").description("Manage AI sessions fo
     });
     console.log(chalk18.green("\u2713 Logged to session"));
   })
+).addCommand(
+  new Command17("sync").description("Sync current session and all actions to the server").action(async () => {
+    const sessionManager2 = getSessionManager();
+    const session = await sessionManager2.getCurrentSession();
+    if (!session) {
+      console.log(chalk18.yellow("No active session to sync"));
+      return;
+    }
+    console.log(chalk18.cyan("Syncing session:"), chalk18.bold(session.id));
+    console.log(chalk18.gray(`Actions to sync: ${session.actions.length}`));
+    const success = await sessionManager2.syncToServer(session);
+    if (success) {
+      console.log(chalk18.green("\u2713 Session synced to server"));
+    } else {
+      console.log(chalk18.yellow("\u26A0 Sync failed (not logged in or server unavailable)"));
+    }
+  })
 );
 function formatDuration(start, end) {
   const ms = new Date(end).getTime() - new Date(start).getTime();
@@ -3265,7 +3499,7 @@ function formatDuration(start, end) {
 import { Command as Command18 } from "commander";
 import ora13 from "ora";
 import chalk19 from "chalk";
-import { AuthManager as AuthManager16, TaskOperations as TaskOperations13 } from "@vibetasks/core";
+import { AuthManager as AuthManager17, TaskOperations as TaskOperations13 } from "@vibetasks/core";
 function parseIndices(args) {
   const indices = /* @__PURE__ */ new Set();
   for (const arg of args) {
@@ -3307,7 +3541,7 @@ var subtaskCommand = new Command18("subtask").description("Manage subtasks withi
 subtaskCommand.command("list").description("List subtasks for a task").argument("<task-id>", "Task ID, short # (1-99), or first 8 characters").action(async (taskIdArg) => {
   const spinner = ora13("Loading subtasks...").start();
   try {
-    const authManager = new AuthManager16();
+    const authManager = new AuthManager17();
     const taskOps = await TaskOperations13.fromAuthManager(authManager);
     const shortIdManager = new ShortIdManager();
     let taskId = await shortIdManager.resolveId(taskIdArg);
@@ -3355,7 +3589,7 @@ Error: ${error.message}
 subtaskCommand.command("done").description("Mark subtasks as complete").argument("<task-id>", "Task ID, short # (1-99), or first 8 characters").argument("<indices...>", 'Subtask indices (1-based): "1 2 3", "1-5", "1,3,5", or partial title match').action(async (taskIdArg, indicesArgs) => {
   const spinner = ora13("Updating subtasks...").start();
   try {
-    const authManager = new AuthManager16();
+    const authManager = new AuthManager17();
     const taskOps = await TaskOperations13.fromAuthManager(authManager);
     const shortIdManager = new ShortIdManager();
     let taskId = await shortIdManager.resolveId(taskIdArg);
@@ -3431,7 +3665,7 @@ Error: ${error.message}
 subtaskCommand.command("undo").description("Mark subtasks as incomplete").argument("<task-id>", "Task ID, short # (1-99), or first 8 characters").argument("<indices...>", 'Subtask indices (1-based): "1 2 3", "1-5", "1,3,5", or partial title match').action(async (taskIdArg, indicesArgs) => {
   const spinner = ora13("Updating subtasks...").start();
   try {
-    const authManager = new AuthManager16();
+    const authManager = new AuthManager17();
     const taskOps = await TaskOperations13.fromAuthManager(authManager);
     const shortIdManager = new ShortIdManager();
     let taskId = await shortIdManager.resolveId(taskIdArg);
@@ -3505,7 +3739,7 @@ Error: ${error.message}
 import { Command as Command19 } from "commander";
 import chalk20 from "chalk";
 import ora14 from "ora";
-import { AuthManager as AuthManager17, TaskOperations as TaskOperations14 } from "@vibetasks/core";
+import { AuthManager as AuthManager18, TaskOperations as TaskOperations14 } from "@vibetasks/core";
 import {
   parseError,
   generateErrorTaskTitle as generateErrorTaskTitle3,
@@ -3603,7 +3837,7 @@ var errorCommand = new Command19("error").description("Capture an error and crea
       process.exit(1);
     }
     spinner.start("Creating error task...");
-    const authManager = new AuthManager17();
+    const authManager = new AuthManager18();
     const taskOps = await TaskOperations14.fromAuthManager(authManager);
     const errorContext = parseError(errorText, "terminal");
     const title = errorContext ? generateErrorTaskTitle3(errorContext) : `Error: ${errorText.split("\n")[0].slice(0, 80)}`;
@@ -3643,7 +3877,7 @@ ${errorText}
 import { Command as Command20 } from "commander";
 import chalk21 from "chalk";
 import Table3 from "cli-table3";
-import { AuthManager as AuthManager18, TaskOperations as TaskOperations15 } from "@vibetasks/core";
+import { AuthManager as AuthManager19, TaskOperations as TaskOperations15 } from "@vibetasks/core";
 var sourceDisplay = {
   sentry: { label: "Sentry", color: chalk21.red },
   ci: { label: "CI", color: chalk21.yellow },
@@ -3670,7 +3904,7 @@ function formatSource(sourceType) {
 }
 var inboxCommand = new Command20("inbox").description("View inbox items from all sources (Sentry, GitHub, Email, Slack, CI)").option("-s, --source <source>", "Filter by source: sentry, ci, github, email, slack, errors, feedback").option("-p, --priority <priority>", "Filter by priority: high, medium, low").option("-a, --all", "Include acknowledged items").option("-l, --limit <number>", "Maximum items to show", "20").action(async (options) => {
   try {
-    const authManager = new AuthManager18();
+    const authManager = new AuthManager19();
     const taskOps = await TaskOperations15.fromAuthManager(authManager);
     let sourceTypes;
     if (options.source) {
@@ -3779,7 +4013,7 @@ Error: ${error.message}
 });
 var inboxStatsCommand = new Command20("stats").description("Show inbox statistics").action(async () => {
   try {
-    const authManager = new AuthManager18();
+    const authManager = new AuthManager19();
     const taskOps = await TaskOperations15.fromAuthManager(authManager);
     const stats = await taskOps.getInboxStats();
     console.log("\n" + chalk21.bold("Inbox Statistics") + "\n");
@@ -3835,10 +4069,1267 @@ Error: ${error.message}
 });
 inboxCommand.addCommand(inboxStatsCommand);
 
+// src/commands/handoff.ts
+import { Command as Command21 } from "commander";
+import chalk22 from "chalk";
+import { AuthManager as AuthManager20, TaskOperations as TaskOperations16 } from "@vibetasks/core";
+var handoffCommand = new Command21("handoff").description("Generate comprehensive handoff for the next AI (vibing tasks, context notes, git status)").argument("[session-id]", "Session ID (shows that session only)").option("--full", "Include full action history from session").action(async (sessionId, options) => {
+  const sessionManager2 = getSessionManager();
+  if (sessionId) {
+    const handoff = await sessionManager2.getSessionHandoff(sessionId);
+    console.log(handoff);
+    return;
+  }
+  console.log(chalk22.cyan("# AI Handoff"));
+  console.log(chalk22.gray(`Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}`));
+  console.log();
+  const currentSession = await sessionManager2.getCurrentSession();
+  if (currentSession) {
+    console.log(chalk22.yellow("## Session"));
+    console.log(`ID: ${chalk22.bold(currentSession.id)}`);
+    console.log(`Project: ${currentSession.project || "unknown"}`);
+    console.log(`Started: ${new Date(currentSession.startedAt).toLocaleString()}`);
+    console.log(`Actions: ${currentSession.actions.length}`);
+    if (currentSession.summary) {
+      console.log(`Summary: ${currentSession.summary}`);
+    }
+    console.log();
+  }
+  try {
+    const authManager = new AuthManager20();
+    const taskOps = await TaskOperations16.fromAuthManager(authManager);
+    const allTasks = await taskOps.getTasks("all");
+    const vibingTasks = allTasks.filter((t) => t.status === "vibing");
+    if (vibingTasks.length > 0) {
+      console.log(chalk22.yellow("## Vibing Tasks (Active Work)"));
+      console.log();
+      for (const task of vibingTasks) {
+        const shortId = task.short_id || task.id.slice(0, 8);
+        console.log(chalk22.green(`### #${shortId}: ${task.title}`));
+        if (task.project_tag) {
+          console.log(chalk22.gray(`Project: ${task.project_tag}`));
+        }
+        const subtasks = task.subtasks_json || task.subtasks || [];
+        if (subtasks.length > 0) {
+          const done = subtasks.filter((s) => s.done).length;
+          console.log(`Progress: ${done}/${subtasks.length} subtasks`);
+          subtasks.forEach((s, i) => {
+            const status = s.done ? chalk22.green("\u2713") : chalk22.gray("\u25CB");
+            const title = s.done ? chalk22.gray(s.title) : s.title;
+            console.log(`  ${status} ${i + 1}. ${title}`);
+          });
+        }
+        if (task.context_notes) {
+          console.log();
+          console.log(chalk22.cyan("Where I left off:"));
+          console.log(task.context_notes);
+        } else {
+          console.log();
+          console.log(chalk22.yellow("\u26A0 No context notes - update with:"));
+          console.log(chalk22.gray(`  vibetasks update ${shortId} --context "..."`));
+        }
+        console.log();
+      }
+    } else {
+      console.log(chalk22.yellow("## No Vibing Tasks"));
+      console.log(chalk22.gray("All clear - ready for new work."));
+      console.log();
+    }
+  } catch (error) {
+    console.log(chalk22.gray("(Could not fetch tasks - may need to login)"));
+    console.log();
+  }
+  try {
+    const { execSync: execSync2 } = await import("child_process");
+    const gitStatus = execSync2("git status --porcelain", { encoding: "utf-8", timeout: 5e3 }).trim();
+    if (gitStatus) {
+      const files = gitStatus.split("\n");
+      console.log(chalk22.yellow(`## Uncommitted Changes (${files.length} files)`));
+      files.slice(0, 15).forEach((f) => console.log(chalk22.gray(`  ${f}`)));
+      if (files.length > 15) {
+        console.log(chalk22.gray(`  ... and ${files.length - 15} more`));
+      }
+      console.log();
+    }
+    const commits = execSync2("git log --oneline -3", { encoding: "utf-8", timeout: 5e3 }).trim();
+    if (commits) {
+      console.log(chalk22.yellow("## Recent Commits"));
+      commits.split("\n").forEach((c) => console.log(chalk22.gray(`  ${c}`)));
+      console.log();
+    }
+  } catch {
+  }
+  console.log(chalk22.cyan("\u2500".repeat(60)));
+  console.log(chalk22.yellow("## For Next AI"));
+  console.log();
+  console.log("1. Run: `vibetasks session current || vibetasks session start`");
+  console.log("2. Run: `vibetasks list --status vibing --short-ids`");
+  console.log('3. Read context_notes above for "where I left off"');
+  console.log("4. Continue the vibing task or ask user what to do");
+  if (currentSession) {
+    console.log();
+    console.log(chalk22.gray(`To reference this session: "Continue from session ${currentSession.id}"`));
+  }
+});
+
+// src/commands/parse-prd.ts
+import { Command as Command22 } from "commander";
+import ora15 from "ora";
+import chalk23 from "chalk";
+import { readFile as readFile3 } from "fs/promises";
+import { existsSync } from "fs";
+import { AuthManager as AuthManager21, TaskOperations as TaskOperations17 } from "@vibetasks/core";
+import { detectProject as detectProject6 } from "@vibetasks/shared/utils/project-detector";
+import { randomUUID as randomUUID3 } from "crypto";
+var parsePrdCommand = new Command22("parse-prd").description("Parse a PRD/requirements document and create tasks").argument("<file>", "Path to PRD/requirements file (markdown)").option("-t, --title <title>", "Override task title (auto-generated if not provided)").option("-p, --priority <level>", "Priority: low, medium, high", "high").option("--project <name>", "Override auto-detected project").option("--dry-run", "Show what would be created without creating").option("-v, --verbose", "Show detailed parsing output").action(async (filePath, options) => {
+  const spinner = ora15("Parsing PRD...").start();
+  try {
+    if (!existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    const content = await readFile3(filePath, "utf-8");
+    spinner.text = "Analyzing document structure...";
+    const parsed = parsePrdContent(content, options.verbose);
+    if (options.verbose) {
+      spinner.info("Parsed structure:");
+      console.log(chalk23.gray(`  Title: ${parsed.title}`));
+      console.log(chalk23.gray(`  Summary: ${parsed.summary?.substring(0, 100)}...`));
+      console.log(chalk23.gray(`  Sections: ${parsed.sections.length}`));
+      console.log(chalk23.gray(`  Tasks: ${parsed.tasks.length}`));
+      spinner.start("Continuing...");
+    }
+    const finalTitle = options.title || parsed.title || "Implement PRD";
+    const subtasksJson = parsed.tasks.map((task2, i) => ({
+      id: randomUUID3(),
+      title: task2,
+      done: false
+    }));
+    const acceptanceCriteria = parsed.acceptanceCriteria || [];
+    let notes = "";
+    if (parsed.summary) {
+      notes += `## Summary
+${parsed.summary}
+
+`;
+    }
+    if (acceptanceCriteria.length > 0) {
+      notes += `DONE WHEN:
+${acceptanceCriteria.map((c) => `- ${c}`).join("\n")}
+
+`;
+    }
+    if (parsed.nonGoals && parsed.nonGoals.length > 0) {
+      notes += `## Out of Scope
+${parsed.nonGoals.map((n) => `- ${n}`).join("\n")}
+`;
+    }
+    if (options.dryRun) {
+      spinner.succeed(chalk23.yellow("Dry run - no task created"));
+      console.log();
+      console.log(chalk23.white.bold(`Task: ${finalTitle}`));
+      console.log(chalk23.gray(`Priority: ${options.priority}`));
+      console.log();
+      if (subtasksJson.length > 0) {
+        console.log(chalk23.cyan("Subtasks:"));
+        subtasksJson.forEach((st, i) => {
+          console.log(chalk23.gray(`  ${i + 1}. ${st.title}`));
+        });
+        console.log();
+      }
+      if (acceptanceCriteria.length > 0) {
+        console.log(chalk23.green("Acceptance Criteria:"));
+        acceptanceCriteria.forEach((c, i) => {
+          console.log(chalk23.gray(`  \u2713 ${c}`));
+        });
+        console.log();
+      }
+      if (parsed.nonGoals && parsed.nonGoals.length > 0) {
+        console.log(chalk23.red("Non-Goals (out of scope):"));
+        parsed.nonGoals.forEach((n) => {
+          console.log(chalk23.gray(`  \u2717 ${n}`));
+        });
+      }
+      process.exit(0);
+      return;
+    }
+    spinner.text = "Creating task...";
+    const authManager = new AuthManager21();
+    const taskOps = await TaskOperations17.fromAuthManager(authManager);
+    let projectTag;
+    if (options.project) {
+      projectTag = options.project;
+    } else {
+      try {
+        const detected = await detectProject6(process.cwd());
+        projectTag = detected.fullName || detected.name;
+      } catch {
+      }
+    }
+    let sessionId;
+    let sessionHistory = [];
+    const sessionManager2 = getSessionManager();
+    const currentSession = await sessionManager2.getCurrentSession();
+    if (currentSession) {
+      sessionId = currentSession.id;
+      sessionHistory = [{
+        session_id: currentSession.id,
+        action: "created",
+        at: (/* @__PURE__ */ new Date()).toISOString()
+      }];
+    }
+    const task = await taskOps.createTask({
+      title: finalTitle,
+      notes,
+      notes_format: "markdown",
+      priority: options.priority,
+      project_tag: projectTag,
+      created_by: "ai",
+      status: "todo",
+      subtasks_json: subtasksJson,
+      session_id: sessionId,
+      session_history: sessionHistory,
+      is_plan: true
+      // Mark as a plan task
+    });
+    try {
+      const shortIdManager = new ShortIdManager();
+      const allTasks = await taskOps.getTasks("all");
+      await shortIdManager.saveMappings(allTasks);
+    } catch {
+    }
+    if (currentSession) {
+      await sessionManager2.logAction({
+        type: "task_created",
+        description: `Created task from PRD: "${finalTitle}"`,
+        taskId: task.id,
+        taskTitle: finalTitle
+      });
+    }
+    spinner.succeed(chalk23.green("Task created from PRD!"));
+    console.log();
+    console.log(chalk23.white.bold(finalTitle));
+    if (projectTag) {
+      console.log(chalk23.gray(`\u{1F4C1} Project: ${chalk23.white(projectTag)}`));
+    }
+    console.log(chalk23.gray(`ID: ${task.id.substring(0, 8)}...`));
+    console.log();
+    if (subtasksJson.length > 0) {
+      console.log(chalk23.cyan(`\u{1F4CB} ${subtasksJson.length} subtasks created:`));
+      subtasksJson.slice(0, 10).forEach((st, i) => {
+        console.log(chalk23.gray(`  ${i + 1}. ${st.title}`));
+      });
+      if (subtasksJson.length > 10) {
+        console.log(chalk23.gray(`  ... and ${subtasksJson.length - 10} more`));
+      }
+      console.log();
+    }
+    if (acceptanceCriteria.length > 0) {
+      console.log(chalk23.green(`\u2713 ${acceptanceCriteria.length} acceptance criteria defined`));
+    }
+    console.log();
+    console.log(chalk23.gray("Start working with:"));
+    console.log(chalk23.white(`  vibetasks vibing ${task.short_id || task.id.substring(0, 8)}`));
+    console.log();
+    process.exit(0);
+  } catch (error) {
+    spinner.fail(chalk23.red("Failed to parse PRD"));
+    if (error.message.includes("Not authenticated")) {
+      console.error(chalk23.yellow("\n\u26A0\uFE0F  You need to login first"));
+      console.error(chalk23.gray("Run: vibetasks login\n"));
+    } else {
+      console.error(chalk23.red(`
+Error: ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+function parsePrdContent(content, verbose = false) {
+  const lines = content.split("\n");
+  const result = {
+    title: "",
+    sections: [],
+    tasks: [],
+    acceptanceCriteria: [],
+    nonGoals: []
+  };
+  const h1Match = content.match(/^#\s+(.+)$/m);
+  if (h1Match) {
+    result.title = h1Match[1].trim();
+  }
+  const summaryMatch = content.match(/^#\s+.+\n\n([\s\S]*?)(?=\n##|$)/);
+  if (summaryMatch) {
+    result.summary = summaryMatch[1].trim().split("\n\n")[0];
+  }
+  const sectionPattern = /^##\s+(.+)$/gm;
+  let match;
+  while ((match = sectionPattern.exec(content)) !== null) {
+    result.sections.push(match[1].trim());
+  }
+  const taskPatterns = [
+    /^[-*]\s+\[[ x]\]\s+(.+)$/gm,
+    // Checkbox items
+    /^[-*]\s+(.+)$/gm,
+    // Regular bullet points under task-like headers
+    /^\d+\.\s+(.+)$/gm
+    // Numbered items
+  ];
+  const taskSectionPatterns = [
+    /##\s*(?:tasks?|implementation|steps?|work breakdown|subtasks?)\s*\n([\s\S]*?)(?=\n##|$)/gi,
+    /##\s*(?:requirements?|deliverables?|milestones?)\s*\n([\s\S]*?)(?=\n##|$)/gi
+  ];
+  for (const pattern of taskSectionPatterns) {
+    let sectionMatch;
+    while ((sectionMatch = pattern.exec(content)) !== null) {
+      const sectionContent = sectionMatch[1];
+      const bulletPattern = /^[-*]\s+(.+)$/gm;
+      let bulletMatch;
+      while ((bulletMatch = bulletPattern.exec(sectionContent)) !== null) {
+        const task = bulletMatch[1].trim();
+        const cleanTask = task.replace(/^\[[ x]\]\s*/, "").trim();
+        if (cleanTask && !result.tasks.includes(cleanTask)) {
+          result.tasks.push(cleanTask);
+        }
+      }
+      const numberedPattern = /^\d+\.\s+(.+)$/gm;
+      while ((bulletMatch = numberedPattern.exec(sectionContent)) !== null) {
+        const task = bulletMatch[1].trim();
+        if (task && !result.tasks.includes(task)) {
+          result.tasks.push(task);
+        }
+      }
+    }
+  }
+  if (result.tasks.length === 0) {
+    const bulletPattern = /^[-*]\s+(.+)$/gm;
+    while ((match = bulletPattern.exec(content)) !== null) {
+      const task = match[1].trim();
+      if (!task.toLowerCase().includes("done when") && !task.toLowerCase().includes("success") && !task.toLowerCase().includes("criterion")) {
+        result.tasks.push(task);
+      }
+    }
+  }
+  const criteriaPatterns = [
+    /##\s*(?:goals?|success criteria|acceptance criteria|done when|definition of done)\s*\n([\s\S]*?)(?=\n##|$)/gi
+  ];
+  for (const pattern of criteriaPatterns) {
+    let criteriaMatch;
+    while ((criteriaMatch = pattern.exec(content)) !== null) {
+      const sectionContent = criteriaMatch[1];
+      const bulletPattern = /^[-*]\s+(.+)$/gm;
+      let bulletMatch;
+      while ((bulletMatch = bulletPattern.exec(sectionContent)) !== null) {
+        const criterion = bulletMatch[1].trim();
+        if (criterion && !result.acceptanceCriteria.includes(criterion)) {
+          result.acceptanceCriteria.push(criterion);
+        }
+      }
+    }
+  }
+  const nonGoalPatterns = [
+    /##\s*(?:non-goals?|out of scope|not in scope|exclusions?)\s*\n([\s\S]*?)(?=\n##|$)/gi
+  ];
+  for (const pattern of nonGoalPatterns) {
+    let nonGoalMatch;
+    while ((nonGoalMatch = pattern.exec(content)) !== null) {
+      const sectionContent = nonGoalMatch[1];
+      const bulletPattern = /^[-*]\s+(.+)$/gm;
+      let bulletMatch;
+      while ((bulletMatch = bulletPattern.exec(sectionContent)) !== null) {
+        const nonGoal = bulletMatch[1].trim();
+        if (nonGoal && !result.nonGoals.includes(nonGoal)) {
+          result.nonGoals.push(nonGoal);
+        }
+      }
+    }
+  }
+  if (result.tasks.length > 20) {
+    result.tasks = result.tasks.slice(0, 20);
+  }
+  return result;
+}
+
+// src/commands/checkpoint.ts
+import { Command as Command23 } from "commander";
+import chalk24 from "chalk";
+import { AuthManager as AuthManager22, TaskOperations as TaskOperations18 } from "@vibetasks/core";
+import { execSync } from "child_process";
+import * as readline from "readline";
+var checkpointCommand = new Command23("checkpoint").alias("cp").description("Quick context save for current work (interactive)").argument("[task-id]", "Task ID (defaults to your vibing task)").option("-q, --quick", "Quick mode: just git diff + timestamp, no prompts").option("-m, --message <msg>", "Context message (skip prompt)").option("--no-git", "Skip git diff attachment").action(async (taskId, options) => {
+  try {
+    const authManager = new AuthManager22();
+    const taskOps = await TaskOperations18.fromAuthManager(authManager);
+    const sessionManager2 = getSessionManager();
+    let task;
+    if (taskId) {
+      const allTasks = await taskOps.getTasks("all");
+      task = allTasks.find(
+        (t) => t.id.startsWith(taskId) || t.short_id?.toString() === taskId
+      );
+      if (!task) {
+        console.error(chalk24.red(`Task not found: ${taskId}`));
+        process.exit(1);
+      }
+    } else {
+      const currentSession2 = await sessionManager2.getCurrentSession();
+      const allTasks = await taskOps.getTasks("all");
+      const vibingTasks = allTasks.filter((t) => t.status === "vibing");
+      if (vibingTasks.length === 0) {
+        console.error(chalk24.yellow("No vibing tasks found"));
+        console.error(chalk24.gray("Start one with: vibetasks vibing <task-id>"));
+        process.exit(1);
+      }
+      if (vibingTasks.length === 1) {
+        task = vibingTasks[0];
+      } else {
+        const sessionTask = currentSession2 ? vibingTasks.find((t) => t.session_id === currentSession2.fullId) : null;
+        if (sessionTask) {
+          task = sessionTask;
+        } else {
+          console.log(chalk24.yellow("Multiple vibing tasks found:"));
+          vibingTasks.forEach((t, i) => {
+            console.log(chalk24.gray(`  ${i + 1}. [${t.short_id || t.id.slice(0, 8)}] ${t.title}`));
+          });
+          console.log(chalk24.gray("\nSpecify task: vibetasks checkpoint <task-id>"));
+          process.exit(1);
+        }
+      }
+    }
+    console.log(chalk24.cyan("Checkpointing:"), chalk24.bold(task.title));
+    console.log(chalk24.gray(`ID: ${task.short_id || task.id.slice(0, 8)}`));
+    console.log();
+    let contextParts = [];
+    let gitDiff = "";
+    if (options.git !== false) {
+      try {
+        gitDiff = getGitContext();
+        if (gitDiff) {
+          contextParts.push(`## Git Changes
+\`\`\`
+${gitDiff}
+\`\`\``);
+          console.log(chalk24.green("\u2713"), chalk24.gray("Captured git changes"));
+        }
+      } catch {
+      }
+    }
+    if (options.quick) {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      contextParts.unshift(`Checkpoint at ${timestamp}`);
+      const contextNotes2 = contextParts.join("\n\n");
+      await taskOps.updateTask(task.id, { context_notes: contextNotes2 });
+      console.log(chalk24.green("\u2713 Quick checkpoint saved"));
+      process.exit(0);
+    }
+    if (options.message) {
+      contextParts.unshift(`## Progress
+${options.message}`);
+      const contextNotes2 = contextParts.join("\n\n");
+      await taskOps.updateTask(task.id, { context_notes: contextNotes2 });
+      console.log(chalk24.green("\u2713 Checkpoint saved"));
+      process.exit(0);
+    }
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const prompt = (question) => {
+      return new Promise((resolve) => {
+        rl.question(chalk24.cyan(question), (answer) => {
+          resolve(answer.trim());
+        });
+      });
+    };
+    console.log(chalk24.gray("Press Enter to skip any question\n"));
+    const completed = await prompt("What did you just complete? ");
+    if (completed) {
+      contextParts.unshift(`## Completed
+${completed}`);
+    }
+    const nextStep = await prompt("What's the next step? ");
+    if (nextStep) {
+      contextParts.push(`## Next
+${nextStep}`);
+    }
+    const blockers = await prompt("Any blockers? (or press Enter) ");
+    if (blockers) {
+      contextParts.push(`## Blockers
+${blockers}`);
+    }
+    rl.close();
+    if (contextParts.length === 0) {
+      console.log(chalk24.yellow("Nothing to save (all fields empty)"));
+      process.exit(0);
+    }
+    const contextNotes = contextParts.join("\n\n");
+    await taskOps.updateTask(task.id, { context_notes: contextNotes });
+    const currentSession = await sessionManager2.getCurrentSession();
+    if (currentSession) {
+      await sessionManager2.logAction({
+        type: "task_updated",
+        description: `Checkpoint: ${task.title}`,
+        taskId: task.id,
+        taskTitle: task.title
+      });
+    }
+    console.log();
+    console.log(chalk24.green("\u2713 Checkpoint saved"));
+    console.log(chalk24.gray("Context will be available for the next AI session"));
+    process.exit(0);
+  } catch (error) {
+    if (error.message.includes("Not authenticated")) {
+      console.error(chalk24.yellow("\n\u26A0\uFE0F  You need to login first"));
+      console.error(chalk24.gray("Run: vibetasks login\n"));
+    } else {
+      console.error(chalk24.red(`
+Error: ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+function getGitContext() {
+  const parts = [];
+  try {
+    const branch = execSync("git branch --show-current", { encoding: "utf-8" }).trim();
+    parts.push(`Branch: ${branch}`);
+    const status = execSync("git status --porcelain", { encoding: "utf-8" }).trim();
+    if (status) {
+      const lines = status.split("\n").slice(0, 20);
+      parts.push(`
+Changed files:
+${lines.join("\n")}`);
+      if (status.split("\n").length > 20) {
+        parts.push(`... and ${status.split("\n").length - 20} more`);
+      }
+    }
+    const log = execSync("git log --oneline -3", { encoding: "utf-8" }).trim();
+    if (log) {
+      parts.push(`
+Recent commits:
+${log}`);
+    }
+  } catch {
+    return "";
+  }
+  return parts.join("\n");
+}
+
+// src/commands/log.ts
+import { Command as Command24 } from "commander";
+import chalk25 from "chalk";
+import { AuthManager as AuthManager23, TaskOperations as TaskOperations19 } from "@vibetasks/core";
+var logCommand = new Command24("log").description("Show change history for a task (like git log)").argument("[task]", "Task ID or short number").option("-n, --limit <number>", "Maximum number of changes to show", "20").option("--oneline", "Compact one-line format").option("--since <date>", "Show changes after date (YYYY-MM-DD)").option("--until <date>", "Show changes before date (YYYY-MM-DD)").option("--type <types>", "Filter by change type (comma-separated)").option("--grep <query>", "Search change messages (ignores task arg)").option("--session <id>", "Show changes from specific session").action(async (taskArg, options) => {
+  try {
+    const authManager = new AuthManager23();
+    const taskOps = await TaskOperations19.fromAuthManager(authManager);
+    if (options.grep) {
+      const changes2 = await taskOps.searchChanges(options.grep, parseInt(options.limit, 10));
+      if (changes2.length === 0) {
+        console.log(chalk25.gray(`
+No changes found matching: "${options.grep}"
+`));
+        process.exit(0);
+      }
+      console.log(chalk25.gray(`
+Found ${changes2.length} change(s) matching "${options.grep}":
+`));
+      for (const change of changes2) {
+        printChange(change, options.oneline);
+      }
+      process.exit(0);
+    }
+    if (!taskArg) {
+      console.error(chalk25.red("Error: Task ID or number required"));
+      console.error(chalk25.gray('Usage: vibetasks log <task-id> or vibetasks log --grep "query"'));
+      process.exit(1);
+    }
+    let taskId = taskArg;
+    if (/^\d+$/.test(taskArg)) {
+      const shortIdManager = new ShortIdManager();
+      const resolved = await shortIdManager.resolveId(taskArg);
+      if (resolved) {
+        taskId = resolved;
+      } else {
+        console.error(chalk25.red(`Task #${taskArg} not found`));
+        console.error(chalk25.gray("Run: vibetasks list --short-ids to see available tasks"));
+        process.exit(1);
+      }
+    }
+    const task = await taskOps.getTask(taskId);
+    const queryOptions = {
+      limit: parseInt(options.limit, 10)
+    };
+    if (options.since) {
+      queryOptions.since = new Date(options.since).toISOString();
+    }
+    if (options.until) {
+      queryOptions.until = new Date(options.until).toISOString();
+    }
+    if (options.type) {
+      queryOptions.changeTypes = options.type.split(",").map((t) => t.trim());
+    }
+    const changes = await taskOps.getTaskChanges(taskId, queryOptions);
+    if (changes.length === 0) {
+      console.log(chalk25.gray(`
+No change history found for task: ${task.title}
+`));
+      process.exit(0);
+    }
+    console.log();
+    console.log(chalk25.cyan.bold(`History for: ${task.title}`));
+    console.log(chalk25.gray(`Task ID: ${taskId}`));
+    console.log(chalk25.gray(`Status: ${task.status} | Changes: ${changes.length}`));
+    console.log();
+    for (const change of changes) {
+      printChange(change, options.oneline, task.title);
+    }
+    console.log();
+    process.exit(0);
+  } catch (error) {
+    if (error.message.includes("Not authenticated")) {
+      console.error(chalk25.yellow("\nYou need to login first"));
+      console.error(chalk25.gray("Run: vibetasks login\n"));
+    } else {
+      console.error(chalk25.red(`
+Error: ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+function printChange(change, oneline = false, taskTitle) {
+  const changeId = change.id.substring(0, 8);
+  const date = new Date(change.created_at);
+  const dateStr = date.toLocaleDateString();
+  const timeStr = date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+  const typeColors = {
+    created: chalk25.green,
+    status_changed: chalk25.cyan,
+    title_changed: chalk25.yellow,
+    context_updated: chalk25.blue,
+    priority_changed: chalk25.magenta,
+    subtask_done: chalk25.green,
+    subtask_undone: chalk25.red,
+    subtask_added: chalk25.cyan,
+    archived: chalk25.gray,
+    restored: chalk25.green,
+    revert: chalk25.red,
+    handoff: chalk25.magenta
+  };
+  const colorFn = typeColors[change.change_type] || chalk25.white;
+  const actorIcon = change.actor_type === "ai" ? "\u{1F916}" : change.actor_type === "human" ? "\u{1F464}" : "\u2699\uFE0F";
+  if (oneline) {
+    const message = change.message || change.change_type;
+    console.log(
+      `${chalk25.yellow(changeId)} ${chalk25.gray(dateStr)} ${colorFn(change.change_type.padEnd(16))} ${actorIcon} ${message}`
+    );
+  } else {
+    console.log(chalk25.yellow(`change ${change.id}`));
+    console.log(`Actor:  ${actorIcon} ${change.actor_type}`);
+    console.log(`Date:   ${dateStr} ${timeStr}`);
+    if (change.session_id) {
+      console.log(chalk25.gray(`Session: ${change.session_id.substring(0, 8)}`));
+    }
+    console.log();
+    console.log(`    ${colorFn(change.change_type)}: ${change.message || ""}`);
+    if (change.old_value !== void 0 || change.new_value !== void 0) {
+      if (change.field_changed === "status") {
+        console.log(chalk25.gray(`    ${chalk25.red(`- ${change.old_value}`)} ${chalk25.green(`+ ${change.new_value}`)}`));
+      } else if (change.field_changed === "context_notes") {
+        const oldVal = truncate(String(change.old_value || ""), 60);
+        const newVal = truncate(String(change.new_value || ""), 60);
+        if (oldVal) console.log(chalk25.red(`    - ${oldVal}`));
+        if (newVal) console.log(chalk25.green(`    + ${newVal}`));
+      } else if (change.field_changed === "subtasks") {
+        const newSub = change.new_value;
+        if (newSub?.title) {
+          console.log(chalk25.gray(`    Subtask: ${newSub.title}`));
+        }
+      } else if (change.old_value !== void 0 && change.new_value !== void 0) {
+        console.log(chalk25.red(`    - ${change.old_value}`));
+        console.log(chalk25.green(`    + ${change.new_value}`));
+      }
+    }
+    console.log();
+  }
+}
+function truncate(str, maxLength) {
+  if (!str) return "";
+  if (str.length <= maxLength) return str;
+  return str.substring(0, maxLength - 3) + "...";
+}
+
+// src/commands/show.ts
+import { Command as Command25 } from "commander";
+import chalk26 from "chalk";
+import { AuthManager as AuthManager24, TaskOperations as TaskOperations20 } from "@vibetasks/core";
+var showCommand = new Command25("show").description("Show details of a specific change (like git show)").argument("<change-id>", "Change ID (full or partial)").action(async (changeId, options) => {
+  try {
+    const authManager = new AuthManager24();
+    const taskOps = await TaskOperations20.fromAuthManager(authManager);
+    const change = await taskOps.getChange(changeId);
+    const task = await taskOps.getTask(change.task_id);
+    const date = new Date(change.created_at);
+    const dateStr = date.toLocaleDateString();
+    const timeStr = date.toLocaleTimeString();
+    const actorIcon = change.actor_type === "ai" ? "\u{1F916}" : change.actor_type === "human" ? "\u{1F464}" : "\u2699\uFE0F";
+    console.log();
+    console.log(chalk26.yellow(`change ${change.id}`));
+    console.log(`Task:    ${chalk26.cyan(task.title)}`);
+    console.log(`         ${chalk26.gray(change.task_id)}`);
+    console.log(`Actor:   ${actorIcon} ${change.actor_type}`);
+    console.log(`Date:    ${dateStr} ${timeStr}`);
+    if (change.session_id) {
+      console.log(`Session: ${chalk26.gray(change.session_id)}`);
+    }
+    console.log();
+    console.log(chalk26.bold(`${change.change_type}`));
+    if (change.message) {
+      console.log(`    ${change.message}`);
+    }
+    console.log();
+    if (change.field_changed) {
+      console.log(chalk26.gray(`Field: ${change.field_changed}`));
+      console.log();
+      if (change.old_value !== void 0) {
+        const oldVal = formatValue(change.old_value);
+        console.log(chalk26.red(`- ${oldVal}`));
+      }
+      if (change.new_value !== void 0) {
+        const newVal = formatValue(change.new_value);
+        console.log(chalk26.green(`+ ${newVal}`));
+      }
+    }
+    if (change.reverted_change_id) {
+      console.log();
+      console.log(chalk26.gray(`Reverted change: ${change.reverted_change_id}`));
+    }
+    console.log();
+    process.exit(0);
+  } catch (error) {
+    if (error.message.includes("Not authenticated")) {
+      console.error(chalk26.yellow("\nYou need to login first"));
+      console.error(chalk26.gray("Run: vibetasks login\n"));
+    } else if (error.code === "PGRST116") {
+      console.error(chalk26.red(`
+Change not found: ${changeId}
+`));
+    } else {
+      console.error(chalk26.red(`
+Error: ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+function formatValue(value) {
+  if (value === null || value === void 0) {
+    return "(empty)";
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value, null, 2);
+  }
+  return String(value);
+}
+
+// src/commands/pause.ts
+import { Command as Command26 } from "commander";
+import chalk27 from "chalk";
+import ora16 from "ora";
+import { AuthManager as AuthManager25, TaskOperations as TaskOperations21 } from "@vibetasks/core";
+var pauseCommand = new Command26("pause").description("Pause a task (like git stash) - can be resumed later").argument("[task]", "Task ID or short number to pause").option("-m, --message <reason>", "Reason for pausing").option("-l, --list", "List all paused tasks").action(async (taskArg, options) => {
+  const spinner = ora16();
+  try {
+    const authManager = new AuthManager25();
+    const taskOps = await TaskOperations21.fromAuthManager(authManager);
+    if (options.list) {
+      spinner.start("Fetching paused tasks...");
+      const allTasks = await taskOps.getTasks("all");
+      const pausedTasks = allTasks.filter((t) => t.status === "paused");
+      spinner.stop();
+      if (pausedTasks.length === 0) {
+        console.log(chalk27.yellow("\nNo paused tasks found.\n"));
+        console.log(chalk27.gray('Pause a task with: vibetasks pause <task-id> -m "reason"\n'));
+        process.exit(0);
+      }
+      console.log(chalk27.white("\nPaused Tasks:\n"));
+      pausedTasks.forEach((task2, index) => {
+        console.log(
+          chalk27.gray(`${index + 1}. `) + chalk27.yellow("\u23F8 ") + chalk27.white(task2.title) + chalk27.gray(` [${task2.id.slice(0, 8)}]`)
+        );
+        if (task2.context_notes) {
+          const lastLine = task2.context_notes.split("\n").pop();
+          if (lastLine) {
+            console.log(chalk27.gray(`   \u2514\u2500 ${lastLine}`));
+          }
+        }
+      });
+      console.log(chalk27.gray(`
+Total: ${pausedTasks.length} paused task(s)
+`));
+      console.log(chalk27.gray("Resume with: vibetasks resume <task-id>\n"));
+      process.exit(0);
+    }
+    if (!taskArg) {
+      console.log(chalk27.yellow("\nUsage:"));
+      console.log(chalk27.gray("  vibetasks pause <task-id>     # Pause a specific task"));
+      console.log(chalk27.gray("  vibetasks pause --list        # List paused tasks\n"));
+      process.exit(1);
+    }
+    let taskId = taskArg;
+    if (/^\d+$/.test(taskArg)) {
+      const shortIdManager = new ShortIdManager();
+      const resolved = await shortIdManager.resolveId(taskArg);
+      if (resolved) {
+        taskId = resolved;
+      } else {
+        console.error(chalk27.red(`Task #${taskArg} not found`));
+        console.error(chalk27.gray("Run: vibetasks list --short-ids to see available tasks"));
+        process.exit(1);
+      }
+    } else if (taskArg.length < 32) {
+      const allTasks = await taskOps.getTasks("all");
+      const matchingTask = allTasks.find((t) => t.id.startsWith(taskArg));
+      if (!matchingTask) {
+        console.error(chalk27.red(`Task not found: ${taskArg}`));
+        process.exit(1);
+      }
+      taskId = matchingTask.id;
+    }
+    const task = await taskOps.getTask(taskId);
+    if (task.status === "paused") {
+      console.log(chalk27.yellow(`
+Task is already paused: ${task.title}
+`));
+      console.log(chalk27.gray("Resume with: vibetasks resume " + taskId.slice(0, 8) + "\n"));
+      process.exit(0);
+    }
+    if (task.status === "done" || task.status === "archived") {
+      console.error(chalk27.red(`
+Cannot pause a ${task.status} task.
+`));
+      process.exit(1);
+    }
+    spinner.start("Pausing task...");
+    const pausedTask = await taskOps.pauseTask(taskId, options.message);
+    spinner.succeed(chalk27.green("Task paused!"));
+    console.log();
+    console.log(chalk27.yellow("\u23F8 ") + chalk27.white(pausedTask.title));
+    if (options.message) {
+      console.log(chalk27.gray(`   Reason: ${options.message}`));
+    }
+    console.log();
+    console.log(chalk27.gray(`Resume with: vibetasks resume ${taskId.slice(0, 8)}`));
+    console.log(chalk27.gray(`View paused: vibetasks pause --list`));
+    console.log();
+    process.exit(0);
+  } catch (error) {
+    spinner.fail(chalk27.red("Failed to pause task"));
+    if (error.message.includes("Not authenticated")) {
+      console.error(chalk27.yellow("\nYou need to login first"));
+      console.error(chalk27.gray("Run: vibetasks login\n"));
+    } else {
+      console.error(chalk27.red(`
+Error: ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/resume.ts
+import { Command as Command27 } from "commander";
+import chalk28 from "chalk";
+import ora17 from "ora";
+import inquirer7 from "inquirer";
+import { AuthManager as AuthManager26, TaskOperations as TaskOperations22 } from "@vibetasks/core";
+var resumeCommand = new Command27("resume").description("Resume a paused task (like git stash pop)").argument("[task]", "Task ID or short number to resume (or pick from list)").action(async (taskArg) => {
+  const spinner = ora17();
+  try {
+    const authManager = new AuthManager26();
+    const taskOps = await TaskOperations22.fromAuthManager(authManager);
+    const allTasks = await taskOps.getTasks("all");
+    const pausedTasks = allTasks.filter((t) => t.status === "paused");
+    if (pausedTasks.length === 0) {
+      console.log(chalk28.yellow("\nNo paused tasks to resume.\n"));
+      console.log(chalk28.gray("Pause a task with: vibetasks pause <task-id>\n"));
+      process.exit(0);
+    }
+    let taskId;
+    if (!taskArg) {
+      if (pausedTasks.length === 1) {
+        taskId = pausedTasks[0].id;
+        console.log(chalk28.gray(`
+Auto-selecting the only paused task...
+`));
+      } else {
+        const { selectedTask } = await inquirer7.prompt([{
+          type: "list",
+          name: "selectedTask",
+          message: "Pick a paused task to resume:",
+          choices: pausedTasks.map((t) => ({
+            name: `${chalk28.yellow("\u23F8")} ${t.title}${t.context_notes ? chalk28.gray(` - ${t.context_notes.split("\n").pop()?.slice(0, 40)}...`) : ""}`,
+            value: t.id
+          }))
+        }]);
+        taskId = selectedTask;
+      }
+    } else {
+      taskId = taskArg;
+      if (/^\d+$/.test(taskArg)) {
+        const shortIdManager = new ShortIdManager();
+        const resolved = await shortIdManager.resolveId(taskArg);
+        if (resolved) {
+          taskId = resolved;
+        } else {
+          console.error(chalk28.red(`Task #${taskArg} not found`));
+          console.error(chalk28.gray("Run: vibetasks list --short-ids to see available tasks"));
+          process.exit(1);
+        }
+      } else if (taskArg.length < 32) {
+        const matchingTask = pausedTasks.find((t) => t.id.startsWith(taskArg)) || allTasks.find((t) => t.id.startsWith(taskArg));
+        if (!matchingTask) {
+          console.error(chalk28.red(`Task not found: ${taskArg}`));
+          process.exit(1);
+        }
+        taskId = matchingTask.id;
+      }
+    }
+    const task = await taskOps.getTask(taskId);
+    if (task.status !== "paused") {
+      console.log(chalk28.yellow(`
+Task is not paused (status: ${task.status}): ${task.title}
+`));
+      if (task.status === "todo") {
+        console.log(chalk28.gray("Start vibing with: vibetasks vibing " + taskId.slice(0, 8) + "\n"));
+      }
+      process.exit(0);
+    }
+    spinner.start("Resuming task...");
+    const resumedTask = await taskOps.resumeTask(taskId);
+    spinner.succeed(chalk28.green("Task resumed!"));
+    console.log();
+    console.log(chalk28.magenta("\u26A1 ") + chalk28.white(resumedTask.title));
+    console.log(chalk28.gray(`   Status: vibing`));
+    if (task.context_notes) {
+      console.log(chalk28.gray(`   Context: ${task.context_notes.split("\n").pop()?.slice(0, 60)}...`));
+    }
+    console.log();
+    console.log(chalk28.gray(`Complete with: vibetasks done ${taskId.slice(0, 8)}`));
+    console.log(chalk28.gray(`Pause again:   vibetasks pause ${taskId.slice(0, 8)}`));
+    console.log();
+    process.exit(0);
+  } catch (error) {
+    spinner.fail(chalk28.red("Failed to resume task"));
+    if (error.message.includes("Not authenticated")) {
+      console.error(chalk28.yellow("\nYou need to login first"));
+      console.error(chalk28.gray("Run: vibetasks login\n"));
+    } else {
+      console.error(chalk28.red(`
+Error: ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/revert.ts
+import { Command as Command28 } from "commander";
+import chalk29 from "chalk";
+import ora18 from "ora";
+import inquirer8 from "inquirer";
+import { AuthManager as AuthManager27, TaskOperations as TaskOperations23 } from "@vibetasks/core";
+var revertCommand = new Command28("revert").description("Revert a specific change (like git revert) - non-destructive").argument("[change-id]", "Change ID to revert (or pick from recent changes)").option("-t, --task <task>", "Task ID or number to show changes for").option("-m, --message <message>", "Custom revert message").action(async (changeId, options) => {
+  const spinner = ora18();
+  try {
+    const authManager = new AuthManager27();
+    const taskOps = await TaskOperations23.fromAuthManager(authManager);
+    if (options.task || !changeId) {
+      let taskId;
+      if (options.task) {
+        if (/^\d+$/.test(options.task)) {
+          const shortIdManager = new ShortIdManager();
+          const resolved = await shortIdManager.resolveId(options.task);
+          if (resolved) {
+            taskId = resolved;
+          } else {
+            console.error(chalk29.red(`Task #${options.task} not found`));
+            process.exit(1);
+          }
+        } else if (options.task.length < 32) {
+          const allTasks = await taskOps.getTasks("all");
+          const matchingTask = allTasks.find((t) => t.id.startsWith(options.task));
+          if (matchingTask) {
+            taskId = matchingTask.id;
+          }
+        } else {
+          taskId = options.task;
+        }
+      }
+      if (!taskId) {
+        console.log(chalk29.yellow("\nUsage:"));
+        console.log(chalk29.gray("  vibetasks revert <change-id>           # Revert specific change"));
+        console.log(chalk29.gray("  vibetasks revert --task <task-id>      # Pick from task changes"));
+        console.log(chalk29.gray("  vibetasks log <task-id>                # View changes first\n"));
+        process.exit(1);
+      }
+      const changes = await taskOps.getTaskChanges(taskId, { limit: 20 });
+      const task2 = await taskOps.getTask(taskId);
+      if (changes.length === 0) {
+        console.log(chalk29.yellow(`
+No changes found for task: ${task2.title}
+`));
+        process.exit(0);
+      }
+      const revertableChanges = changes.filter((c) => c.change_type !== "created" && c.change_type !== "revert");
+      if (revertableChanges.length === 0) {
+        console.log(chalk29.yellow(`
+No revertable changes for task: ${task2.title}`));
+        console.log(chalk29.gray("Only the initial creation exists.\n"));
+        process.exit(0);
+      }
+      console.log(chalk29.cyan(`
+Recent changes for: ${task2.title}
+`));
+      const { selectedChange } = await inquirer8.prompt([{
+        type: "list",
+        name: "selectedChange",
+        message: "Select a change to revert:",
+        choices: revertableChanges.map((c) => {
+          const date = new Date(c.created_at).toLocaleDateString();
+          const typeColor = getTypeColor(c.change_type);
+          return {
+            name: `${chalk29.gray(c.id.slice(0, 8))} ${chalk29.gray(date)} ${typeColor(c.change_type)} - ${c.message || "No message"}`,
+            value: c.id
+          };
+        })
+      }]);
+      changeId = selectedChange;
+    }
+    spinner.start("Loading change...");
+    const change = await taskOps.getChange(changeId);
+    const task = await taskOps.getTask(change.task_id);
+    spinner.stop();
+    console.log();
+    console.log(chalk29.cyan("Change to revert:"));
+    console.log(chalk29.gray(`  ID:      ${change.id}`));
+    console.log(chalk29.gray(`  Task:    ${task.title}`));
+    console.log(chalk29.gray(`  Type:    ${change.change_type}`));
+    console.log(chalk29.gray(`  Message: ${change.message || "No message"}`));
+    if (change.old_value !== void 0 || change.new_value !== void 0) {
+      console.log(chalk29.gray(`  Field:   ${change.field_changed}`));
+      if (change.old_value !== void 0) {
+        console.log(chalk29.red(`  Old:     ${formatValue2(change.old_value)}`));
+      }
+      if (change.new_value !== void 0) {
+        console.log(chalk29.green(`  New:     ${formatValue2(change.new_value)}`));
+      }
+    }
+    console.log();
+    const { confirm } = await inquirer8.prompt([{
+      type: "confirm",
+      name: "confirm",
+      message: "Revert this change?",
+      default: true
+    }]);
+    if (!confirm) {
+      console.log(chalk29.gray("\nRevert cancelled.\n"));
+      process.exit(0);
+    }
+    spinner.start("Reverting change...");
+    const revertChange = await taskOps.revertChange(changeId, options.message);
+    spinner.succeed(chalk29.green("Change reverted!"));
+    console.log();
+    console.log(chalk29.yellow("\u21A9 ") + chalk29.white(`Reverted: ${change.message || change.change_type}`));
+    console.log(chalk29.gray(`   Revert ID: ${revertChange.id.slice(0, 8)}`));
+    console.log();
+    console.log(chalk29.gray(`View history: vibetasks log ${task.id.slice(0, 8)}`));
+    console.log();
+    process.exit(0);
+  } catch (error) {
+    spinner.fail(chalk29.red("Failed to revert change"));
+    if (error.message.includes("Not authenticated")) {
+      console.error(chalk29.yellow("\nYou need to login first"));
+      console.error(chalk29.gray("Run: vibetasks login\n"));
+    } else if (error.code === "PGRST116") {
+      console.error(chalk29.red(`
+Change not found: ${changeId}
+`));
+      console.error(chalk29.gray("Use: vibetasks log <task-id> to see valid change IDs\n"));
+    } else {
+      console.error(chalk29.red(`
+Error: ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+function getTypeColor(changeType) {
+  const colors = {
+    created: chalk29.green,
+    status_changed: chalk29.cyan,
+    title_changed: chalk29.yellow,
+    context_updated: chalk29.blue,
+    priority_changed: chalk29.magenta,
+    subtask_done: chalk29.green,
+    subtask_undone: chalk29.red,
+    subtask_added: chalk29.cyan,
+    archived: chalk29.gray,
+    restored: chalk29.green,
+    revert: chalk29.red
+  };
+  return colors[changeType] || chalk29.white;
+}
+function formatValue2(value) {
+  if (value === null || value === void 0) {
+    return "(empty)";
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  const str = String(value);
+  return str.length > 50 ? str.slice(0, 47) + "..." : str;
+}
+
+// src/commands/blame.ts
+import { Command as Command29 } from "commander";
+import chalk30 from "chalk";
+import { AuthManager as AuthManager28, TaskOperations as TaskOperations24 } from "@vibetasks/core";
+var blameCommand = new Command29("blame").description("Show who changed what on a task (like git blame)").argument("<task>", "Task ID or short number").option("-f, --field <field>", "Focus on specific field (status, title, context_notes, priority)").action(async (taskArg, options) => {
+  try {
+    const authManager = new AuthManager28();
+    const taskOps = await TaskOperations24.fromAuthManager(authManager);
+    let taskId = taskArg;
+    if (/^\d+$/.test(taskArg)) {
+      const shortIdManager = new ShortIdManager();
+      const resolved = await shortIdManager.resolveId(taskArg);
+      if (resolved) {
+        taskId = resolved;
+      } else {
+        console.error(chalk30.red(`Task #${taskArg} not found`));
+        console.error(chalk30.gray("Run: vibetasks list --short-ids to see available tasks"));
+        process.exit(1);
+      }
+    } else if (taskArg.length < 32) {
+      const allTasks = await taskOps.getTasks("all", true);
+      const matchingTask = allTasks.find((t) => t.id.startsWith(taskArg));
+      if (!matchingTask) {
+        console.error(chalk30.red(`Task not found: ${taskArg}`));
+        process.exit(1);
+      }
+      taskId = matchingTask.id;
+    }
+    const task = await taskOps.getTask(taskId);
+    const changes = await taskOps.getTaskChanges(taskId, { limit: 100 });
+    if (changes.length === 0) {
+      console.log(chalk30.yellow(`
+No change history for task: ${task.title}
+`));
+      process.exit(0);
+    }
+    const blameMap = {};
+    const currentValues = {
+      status: task.status,
+      title: task.title,
+      priority: task.priority,
+      context_notes: task.context_notes,
+      description: task.description
+    };
+    for (const change of changes) {
+      if (!change.field_changed) continue;
+      if (options.field && change.field_changed !== options.field) continue;
+      if (!blameMap[change.field_changed]) {
+        blameMap[change.field_changed] = {
+          currentValue: currentValues[change.field_changed],
+          changes: []
+        };
+      }
+      blameMap[change.field_changed].changes.push({
+        changeId: change.id,
+        actor: change.session_id?.slice(0, 8) || "unknown",
+        actorType: change.actor_type,
+        date: new Date(change.created_at),
+        oldValue: change.old_value,
+        newValue: change.new_value,
+        message: change.message || change.change_type
+      });
+    }
+    console.log();
+    console.log(chalk30.cyan.bold(`Blame for: ${task.title}`));
+    console.log(chalk30.gray(`Task ID: ${taskId}`));
+    console.log();
+    const fields = options.field ? [options.field] : Object.keys(blameMap).sort();
+    if (fields.length === 0) {
+      console.log(chalk30.yellow("No field changes tracked."));
+      console.log(chalk30.gray("Only status, title, priority, context_notes changes are tracked.\n"));
+      process.exit(0);
+    }
+    for (const field of fields) {
+      const blame = blameMap[field];
+      if (!blame) continue;
+      console.log(chalk30.white.bold(`${field}:`));
+      console.log(chalk30.gray(`  Current: ${formatValue3(blame.currentValue)}`));
+      console.log();
+      for (const change of blame.changes.slice(0, 5)) {
+        const actorIcon = change.actorType === "ai" ? "\u{1F916}" : change.actorType === "human" ? "\u{1F464}" : "\u2699\uFE0F";
+        const dateStr = change.date.toLocaleDateString();
+        const timeStr = change.date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+        console.log(
+          chalk30.gray(`  ${chalk30.yellow(change.changeId.slice(0, 8))} `) + chalk30.gray(`${dateStr} ${timeStr} `) + `${actorIcon} ` + chalk30.white(change.message)
+        );
+        if (change.oldValue !== void 0 || change.newValue !== void 0) {
+          if (field === "status") {
+            console.log(chalk30.gray(`    ${chalk30.red(String(change.oldValue))} \u2192 ${chalk30.green(String(change.newValue))}`));
+          } else {
+            const oldStr = formatValue3(change.oldValue);
+            const newStr = formatValue3(change.newValue);
+            if (oldStr) console.log(chalk30.red(`    - ${oldStr}`));
+            if (newStr) console.log(chalk30.green(`    + ${newStr}`));
+          }
+        }
+      }
+      if (blame.changes.length > 5) {
+        console.log(chalk30.gray(`  ... and ${blame.changes.length - 5} more changes`));
+      }
+      console.log();
+    }
+    const totalChanges = Object.values(blameMap).reduce((sum, b) => sum + b.changes.length, 0);
+    const aiChanges = changes.filter((c) => c.actor_type === "ai").length;
+    const humanChanges = changes.filter((c) => c.actor_type === "human").length;
+    console.log(chalk30.gray("\u2500".repeat(50)));
+    console.log(chalk30.gray(`Total changes: ${totalChanges} | \u{1F916} AI: ${aiChanges} | \u{1F464} Human: ${humanChanges}`));
+    console.log(chalk30.gray(`
+Full history: vibetasks log ${taskId.slice(0, 8)}`));
+    console.log();
+    process.exit(0);
+  } catch (error) {
+    if (error.message.includes("Not authenticated")) {
+      console.error(chalk30.yellow("\nYou need to login first"));
+      console.error(chalk30.gray("Run: vibetasks login\n"));
+    } else {
+      console.error(chalk30.red(`
+Error: ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+function formatValue3(value) {
+  if (value === null || value === void 0) {
+    return "(empty)";
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  const str = String(value);
+  return str.length > 60 ? str.slice(0, 57) + "..." : str;
+}
+
 // bin/vibetasks.ts
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../../package.json");
-var program = new Command21();
+var program = new Command30();
 program.name("vibetasks").description("VibeTasks CLI - Fast task management for vibers").version(pkg.version);
 program.addCommand(setupCommand);
 program.addCommand(loginCommand);
@@ -3861,4 +5352,13 @@ program.addCommand(sessionCommand);
 program.addCommand(subtaskCommand);
 program.addCommand(errorCommand);
 program.addCommand(inboxCommand);
+program.addCommand(handoffCommand);
+program.addCommand(parsePrdCommand);
+program.addCommand(checkpointCommand);
+program.addCommand(logCommand);
+program.addCommand(showCommand);
+program.addCommand(pauseCommand);
+program.addCommand(resumeCommand);
+program.addCommand(revertCommand);
+program.addCommand(blameCommand);
 program.parse();