@vibetasks/cli 0.6.10 → 0.6.13

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 Command37 } 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";
@@ -415,7 +415,8 @@ import { randomUUID as randomUUID2 } from "crypto";
 import { writeFile, readFile, mkdir } from "fs/promises";
 import { join } from "path";
 import { homedir } from "os";
-import { randomUUID } from "crypto";
+import { randomUUID, randomInt } from "crypto";
+import { AuthManager as AuthManager2 } from "@vibetasks/core";
 var ADJECTIVES = [
   "swift",
   "calm",
@@ -455,16 +456,111 @@ 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"
+   * Uses cryptographically secure random generation
    */
   generateSessionId() {
-    const adj = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
-    const noun = NOUNS[Math.floor(Math.random() * NOUNS.length)];
-    const num = Math.floor(Math.random() * 100);
+    const adj = ADJECTIVES[randomInt(ADJECTIVES.length)];
+    const noun = NOUNS[randomInt(NOUNS.length)];
+    const num = randomInt(100);
     return `${adj}-${noun}-${num}`;
   }
   /**
@@ -510,6 +606,8 @@ var SessionManager = class {
     store.sessions.push(session);
     store.currentSession = session.id;
     await this.save();
+    await this.syncToServer(session).catch(() => {
+    });
     return session;
   }
   /**
@@ -532,23 +630,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 +658,8 @@ var SessionManager = class {
       session.summary = summary;
       store.currentSession = void 0;
       await this.save();
+      this.syncToServer(session).catch(() => {
+      });
     }
     return session || null;
   }
@@ -622,6 +721,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: execSync3 } = 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 = execSync3("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 = execSync3("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 +782,114 @@ 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 = 9999;
+  // Support up to 9999 short IDs (database assigns them)
+  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 a partial UUID (8 characters) to full UUID by searching database
+   */
+  async resolvePartialUuid(partialId, taskOps) {
+    if (!/^[0-9a-f]{8}$/i.test(partialId)) {
+      return partialId;
+    }
+    const allTasks = await taskOps.getTasks("all");
+    const matches = allTasks.filter((t) => t.id.toLowerCase().startsWith(partialId.toLowerCase()));
+    if (matches.length === 0) {
+      throw new Error(
+        `No task found starting with "${partialId}". Run 'vibetasks list' to see all tasks.`
+      );
+    }
+    if (matches.length > 1) {
+      const shortIds = matches.map((t) => t.short_id).filter(Boolean);
+      const suggestion = shortIds.length > 0 ? `Try using short ID: ${shortIds.join(" or ")}` : "Provide more characters to narrow down";
+      throw new Error(
+        `Multiple tasks match "${partialId}". ${suggestion}`
+      );
+    }
+    return matches[0].id;
+  }
+  /**
+   * Resolve an ID that could be either short (1-9999), partial UUID (8 chars), or full UUID
+   */
+  async resolveId(idOrShortId, taskOps) {
+    const isOnlyNumeric = /^\d+$/.test(idOrShortId);
+    if (isOnlyNumeric) {
+      const shortId = parseInt(idOrShortId, 10);
+      if (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.`
+        );
+      }
+    }
+    if (taskOps && /^[0-9a-f]{8}$/i.test(idOrShortId)) {
+      return await this.resolvePartialUuid(idOrShortId, taskOps);
+    }
+    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("--subtasks-json <json>", "Rich subtasks as JSON (with instructions, links, warnings, etc.)").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").option("--for <who>", "Who should complete this: human, ai, both (default: both)").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) {
@@ -670,11 +924,41 @@ var addCommand = new Command2("add").description("Add a new task").argument("<ti
         throw new Error(`Invalid energy level. Must be one of: ${validEnergy.join(", ")}`);
       }
     }
-    const subtasksJson = options.subtasks?.map((subtaskTitle) => ({
+    let subtasksJson = [];
+    if (options.subtasksJson) {
+      try {
+        const parsed = JSON.parse(options.subtasksJson);
+        subtasksJson = Array.isArray(parsed) ? parsed : [parsed];
+        subtasksJson = subtasksJson.map((st) => ({
+          id: st.id || randomUUID2(),
+          title: st.title,
+          done: st.done || false,
+          notes: st.notes,
+          assigned_to: st.assigned_to,
+          link: st.link,
+          instructions: st.instructions,
+          aiPrompt: st.aiPrompt,
+          code: st.code,
+          warning: st.warning,
+          tip: st.tip
+        }));
+      } catch (error) {
+        throw new Error(`Invalid subtasks JSON: ${error.message}`);
+      }
+    } else if (options.subtasks) {
+      subtasksJson = options.subtasks.map((subtaskTitle) => ({
+        id: randomUUID2(),
+        title: subtaskTitle,
+        done: false
+      }));
+    }
+    const acceptanceCriteria = options.acceptance?.map((text) => ({
       id: randomUUID2(),
-      title: subtaskTitle,
+      text,
       done: false
     })) || [];
+    const relevantFiles = options.files || [];
+    const nonGoals = options.nonGoals || [];
     let sessionId;
     let sessionHistory = [];
     const sessionManager2 = getSessionManager();
@@ -687,6 +971,7 @@ var addCommand = new Command2("add").description("Add a new task").argument("<ti
         at: (/* @__PURE__ */ new Date()).toISOString()
       }];
     }
+    const assignedTo = options.for === "human" ? "human" : options.for === "ai" ? "ai" : options.for === "both" ? "both" : "both";
     const task = await taskOps.createTask({
       title,
       notes: options.notes,
@@ -697,14 +982,20 @@ var addCommand = new Command2("add").description("Add a new task").argument("<ti
       // AUTO-TAGGED!
       created_by: createdBy,
       // ai or human
+      assigned_to: assignedTo,
+      // who can complete this task
       status: createdBy === "ai" ? "vibing" : "todo",
       // AI tasks start vibing
       energy_required: options.energy,
       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,6 +1006,12 @@ var addCommand = new Command2("add").description("Add a new task").argument("<ti
       await taskOps.linkTaskTags(task.id, tagIds);
     }
     spinner.succeed(chalk3.green("Task created!"));
+    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",
@@ -731,6 +1028,11 @@ var addCommand = new Command2("add").description("Add a new task").argument("<ti
       console.log(chalk3.gray(`\u{1F916} Created by: ${chalk3.cyan("AI")}`));
       console.log(chalk3.gray(`\u26A1 Status: ${chalk3.magenta("vibing")}`));
     }
+    if (assignedTo === "human") {
+      console.log(chalk3.gray(`\u{1F464} For: ${chalk3.yellow("HUMAN TASK")} (AI cannot complete)`));
+    } else if (assignedTo === "ai") {
+      console.log(chalk3.gray(`\u{1F916} For: ${chalk3.cyan("AI TASK")} (human review optional)`));
+    }
     console.log(chalk3.gray(`ID: ${task.id.substring(0, 8)}...`));
     console.log(chalk3.white.bold(task.title));
     if (task.notes) {
@@ -758,8 +1060,35 @@ var addCommand = new Command2("add").description("Add a new task").argument("<ti
       console.log(chalk3.cyan(`Subtasks: ${subtasksJson.length}`));
       subtasksJson.forEach((st, i) => {
         console.log(chalk3.gray(`  ${i + 1}. ${st.title}`));
+        if (st.instructions) {
+          console.log(chalk3.gray(`     \u{1F4DD} Has instructions`));
+        }
+        if (st.link) {
+          console.log(chalk3.gray(`     \u{1F517} Link: ${st.link.label || st.link.url}`));
+        }
+        if (st.code) {
+          console.log(chalk3.gray(`     \u{1F4BB} Has code snippet`));
+        }
+        if (st.warning) {
+          console.log(chalk3.red(`     \u26A0\uFE0F  ${st.warning}`));
+        }
+        if (st.tip) {
+          console.log(chalk3.blue(`     \u{1F4A1} ${st.tip}`));
+        }
       });
     }
+    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) {
@@ -783,82 +1112,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"];
@@ -867,7 +1121,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) {
@@ -882,9 +1136,9 @@ var listCommand = new Command3("list").description("List tasks").argument("[filt
       tasks = tasks.filter((t) => t.created_by === options.createdBy);
     }
     if (options.status) {
-      const validStatuses = ["todo", "vibing", "done"];
+      const validStatuses = ["todo", "vibing", "done", "paused", "archived"];
       if (!validStatuses.includes(options.status)) {
-        console.error(chalk4.red(`Invalid status filter. Must be: todo, vibing, or done`));
+        console.error(chalk4.red(`Invalid status filter. Must be: todo, vibing, done, paused, or archived`));
         process.exit(1);
       }
       tasks = tasks.filter((t) => t.status === options.status);
@@ -980,7 +1234,13 @@ ${filterMessages[filter] || "No tasks found"}.
       const id = task.id.substring(0, 8);
       const status = statusColor(`${statusEmojis[task.status || "todo"]} ${task.status || "todo"}`);
       const title = task.status === "done" ? chalk4.strikethrough(task.title) : task.title;
-      const titleWithAI = task.created_by === "ai" ? `\u{1F916} ${title}` : title;
+      let titleWithIndicators = title;
+      if (task.assigned_to === "human") {
+        titleWithIndicators = `\u{1F464} ${title}`;
+      } else if (task.created_by === "ai") {
+        titleWithIndicators = `\u{1F916} ${title}`;
+      }
+      const titleWithAI = titleWithIndicators;
       const project = task.project_tag ? chalk4.blue(task.project_tag) : chalk4.gray("-");
       const priority = priorityColor(task.priority || "none");
       const dueDate = task.due_date ? task.due_date.split("T")[0] : chalk4.gray("-");
@@ -1030,17 +1290,17 @@ 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);
-    if (taskId.length < 32) {
+    let taskId2 = await shortIdManager.resolveId(id, taskOps);
+    if (taskId2.length < 32) {
       const allTasks = await taskOps.getTasks("all");
-      const matchingTask = allTasks.find((t) => t.id.startsWith(taskId));
+      const matchingTask = allTasks.find((t) => t.id.startsWith(taskId2));
       if (!matchingTask) {
         spinner.fail(chalk5.red("Task not found"));
         console.error(chalk5.gray(`
@@ -1048,11 +1308,11 @@ No task found with ID starting with: ${id}
 `));
         process.exit(1);
       }
-      taskId = matchingTask.id;
+      taskId2 = matchingTask.id;
     }
     const sessionManager2 = getSessionManager();
     const currentSession = await sessionManager2.getOrCreateSession();
-    const existingTask = await taskOps.getTask(taskId);
+    const existingTask = await taskOps.getTask(taskId2);
     const existingHistory = existingTask?.session_history || [];
     const updatedHistory = [
       ...existingHistory,
@@ -1071,8 +1331,8 @@ No task found with ID starting with: ${id}
     if (contextNotes) {
       updatePayload.context_notes = contextNotes;
     }
-    await taskOps.updateTask(taskId, updatePayload);
-    const task = await taskOps.completeTask(taskId);
+    await taskOps.updateTask(taskId2, updatePayload);
+    const task = await taskOps.completeTask(taskId2);
     await sessionManager2.logAction({
       type: "task_completed",
       description: `Completed: "${task.title}"`,
@@ -1093,10 +1353,22 @@ No task found with ID starting with: ${id}
     if (error.message.includes("Not authenticated")) {
       console.error(chalk5.yellow("\n\u26A0\uFE0F  You need to login first"));
       console.error(chalk5.gray("Run: taskflow login\n"));
+    } else if (error.message.includes("not found")) {
+      console.error(chalk5.red(`
+Task not found: ${id}`));
+      console.error(chalk5.gray('Tip: Run "vibetasks list" to see all tasks\n'));
+    } else if (error.message.includes("JSON")) {
+      console.error(chalk5.red(`
+Database error: ${error.message}`));
+      console.error(chalk5.gray("This might be a database schema issue. Check task status in the web dashboard.\n"));
     } else {
       console.error(chalk5.red(`
-Error: ${error.message}
-`));
+Error: ${error.message}`));
+      console.error(chalk5.gray(`
+Task ID: ${taskId || id}`));
+      console.error(chalk5.gray("Full error details:"));
+      console.error(error);
+      console.log();
     }
     process.exit(1);
   }
@@ -1107,16 +1379,20 @@ 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";
-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) => {
+import { spawn, execSync } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+import { AuthManager as AuthManager6, TaskOperations as TaskOperations4, createBranchName } from "@vibetasks/core";
+var __dirname2 = path.dirname(fileURLToPath(import.meta.url));
+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").option("--no-branch", "Skip automatic Git branch creation").option("--branch-type <type>", "Branch type: feature, fix, bugfix, hotfix, chore", "feature").option("--autonomous", "Launch autonomous Ralph loop (external orchestration)").option("--max-iterations <n>", "Maximum iterations for autonomous loop", "10").option("--agent <type>", "Agent to use: vibebot|opencode|claude", "vibebot").option("--no-verify-build", "Skip build verification in autonomous mode").option("--no-verify-tests", "Skip test verification in autonomous mode").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;
+    let taskId2;
     if (taskIdInput) {
-      taskId = await shortIdManager.resolveId(taskIdInput);
+      taskId2 = await shortIdManager.resolveId(taskIdInput, taskOps);
     }
     const allTasks = await taskOps.getTasks("all");
     const vibingTasks = allTasks.filter((t) => t.status === "vibing" && !t.completed);
@@ -1124,7 +1400,7 @@ var vibingCommand = new Command5("vibing").alias("start").alias("v").description
       console.log(chalk6.gray(`
   Currently vibing on ${vibingTasks.length} task(s)`));
     }
-    if (!taskId || options.pick) {
+    if (!taskId2 || options.pick) {
       const todoTasks = allTasks.filter((t) => t.status === "todo" && !t.completed);
       if (todoTasks.length === 0) {
         console.log(chalk6.yellow('\nNo todo tasks found. Add one with `vibetasks add "task title"`\n'));
@@ -1139,10 +1415,10 @@ var vibingCommand = new Command5("vibing").alias("start").alias("v").description
           value: t.id
         }))
       }]);
-      taskId = selectedTask;
+      taskId2 = selectedTask;
     }
     spinner.start("Starting task...");
-    const task = allTasks.find((t) => t.id === taskId);
+    const task = allTasks.find((t) => t.id === taskId2);
     const sessionManager2 = getSessionManager();
     const currentSession = await sessionManager2.getOrCreateSession();
     const existingSessionHistory = task?.session_history || [];
@@ -1158,7 +1434,7 @@ var vibingCommand = new Command5("vibing").alias("start").alias("v").description
         }
       ];
     }
-    await taskOps.updateTask(taskId, {
+    await taskOps.updateTask(taskId2, {
       status: "vibing",
       completed: false,
       session_id: currentSession.id,
@@ -1167,16 +1443,88 @@ var vibingCommand = new Command5("vibing").alias("start").alias("v").description
     });
     spinner.succeed(chalk6.green("Now vibing on:"));
     console.log(chalk6.white(`
-  ${task?.title || taskId}
+  ${task?.title || taskId2}
 `));
     if (lastSession && lastSession.session_id !== currentSession.id) {
       console.log(chalk6.cyan(`  \u{1F4CB} Continuing from session: ${lastSession.session_id}`));
       console.log(chalk6.gray(`  This task has been worked on by ${existingSessionHistory.length} session(s)
 `));
     }
+    if (options.branch !== false && task) {
+      const branchType = options.branchType || "feature";
+      const branchName = createBranchName(
+        { short_id: task.short_id, title: task.title },
+        branchType
+      );
+      console.log(chalk6.cyan(`
+\u{1F33F} Creating branch: ${branchName}`));
+      try {
+        execSync("git rev-parse --git-dir", { stdio: "pipe" });
+        try {
+          execSync(`git rev-parse --verify ${branchName}`, { stdio: "pipe" });
+          console.log(chalk6.yellow(`  Branch already exists. Checking out...`));
+          execSync(`git checkout ${branchName}`, { stdio: "inherit" });
+        } catch {
+          execSync(`git checkout -b ${branchName}`, { stdio: "inherit" });
+        }
+        console.log(chalk6.green(`  \u2713 On branch: ${branchName}`));
+        console.log(chalk6.gray(`  When you merge a PR from this branch, VT-${task.short_id} will auto-complete!
+`));
+        await taskOps.updateTask(taskId2, {
+          context_notes: `Branch: ${branchName}
+${task.context_notes || ""}`
+        });
+      } catch (err) {
+        console.log(chalk6.yellow(`  \u26A0\uFE0F Not in a git repo or git error: ${err.message}`));
+      }
+    }
+    if (options.autonomous) {
+      console.log(chalk6.cyan("\n\u{1F3B5} Starting autonomous Ralph loop...\n"));
+      console.log(chalk6.gray(`  Agent: ${options.agent}`));
+      console.log(chalk6.gray(`  Max Iterations: ${options.maxIterations}`));
+      console.log(chalk6.gray(`  Build Verification: ${options.verifyBuild !== false ? "enabled" : "disabled"}`));
+      console.log(chalk6.gray(`  Test Verification: ${options.verifyTests !== false ? "enabled" : "disabled"}`));
+      console.log(chalk6.gray(`
+  Press Ctrl+C to stop the loop at any time.
+`));
+      const scriptPath = path.join(__dirname2, "../../scripts/vibing-loop.sh");
+      const env = {
+        ...process.env,
+        VERIFY_BUILD: options.verifyBuild !== false ? "true" : "false",
+        VERIFY_TESTS: options.verifyTests !== false ? "true" : "false"
+      };
+      const loopProcess = spawn("bash", [
+        scriptPath,
+        taskId2,
+        options.maxIterations || "10",
+        options.agent || "vibebot"
+      ], {
+        stdio: "inherit",
+        cwd: process.cwd(),
+        env
+      });
+      loopProcess.on("exit", (code) => {
+        if (code === 0) {
+          console.log(chalk6.green("\n\u2705 Autonomous loop completed successfully\n"));
+        } else if (code === null) {
+          console.log(chalk6.yellow("\n\u26A0\uFE0F  Loop interrupted by user\n"));
+        } else {
+          console.log(chalk6.red(`
+\u274C Loop exited with code ${code}
+`));
+        }
+      });
+      loopProcess.on("error", (err) => {
+        console.error(chalk6.red("\n\u274C Failed to start loop:"), err.message);
+        process.exit(1);
+      });
+      return;
+    }
     console.log(chalk6.gray("  Tips:"));
     console.log(chalk6.gray("  \u2022 Update context notes as you work"));
-    console.log(chalk6.gray("  \u2022 Run `vibetasks done " + taskId.slice(0, 8) + "` when finished"));
+    console.log(chalk6.gray("  \u2022 Run `vibetasks done " + taskId2.slice(0, 8) + "` when finished"));
+    console.log(chalk6.gray("  \u2022 Use --autonomous flag to start Ralph loop"));
+    console.log(chalk6.gray("  \u2022 Use --no-branch to skip auto branch creation"));
     console.log(chalk6.gray('  \u2022 In Claude Code, say "show my vibing tasks"\n'));
   } catch (error) {
     spinner.fail(chalk6.red("Failed to start task"));
@@ -1189,10 +1537,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);
@@ -1249,7 +1597,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"));
@@ -1258,21 +1606,10 @@ 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) {
-      const allTasks = await taskOps.getTasks("all");
-      const matchingTask = allTasks.find((t) => t.id.startsWith(id));
-      if (!matchingTask) {
-        spinner.fail(chalk8.red("Task not found"));
-        console.error(chalk8.gray(`
-No task found with ID starting with: ${id}
-`));
-        process.exit(1);
-      }
-      taskId = matchingTask.id;
-    }
+    const shortIdManager = new ShortIdManager();
+    let taskId2 = await shortIdManager.resolveId(id, taskOps);
     const updates = {};
     if (options.title) updates.title = options.title;
     if (options.notes) updates.notes = options.notes;
@@ -1300,7 +1637,7 @@ No task found with ID starting with: ${id}
       }
       updates.energy_required = options.energy;
     }
-    const task = await taskOps.updateTask(taskId, updates);
+    const task = await taskOps.updateTask(taskId2, updates);
     spinner.succeed(chalk8.green("Task updated!"));
     console.log(chalk8.gray(`
 \u2713 ${task.title}
@@ -1325,28 +1662,15 @@ 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 = "";
-    if (id.length < 32) {
-      const allTasks = await taskOps.getTasks("all");
-      const matchingTask = allTasks.find((t) => t.id.startsWith(id));
-      if (!matchingTask) {
-        console.error(chalk9.red("\nTask not found"));
-        console.error(chalk9.gray(`No task found with ID starting with: ${id}
-`));
-        process.exit(1);
-      }
-      taskId = matchingTask.id;
-      taskTitle = matchingTask.title;
-    } else {
-      const task = await taskOps.getTask(taskId);
-      taskTitle = task.title;
-    }
+    const shortIdManager = new ShortIdManager();
+    const taskId2 = await shortIdManager.resolveId(id, taskOps);
+    const task = await taskOps.getTask(taskId2);
+    const taskTitle = task.title;
     if (!options.yes) {
       const answers = await inquirer2.prompt([
         {
@@ -1362,7 +1686,7 @@ var deleteCommand = new Command8("delete").description("Delete a task").argument
       }
     }
     const spinner = ora6("Deleting task...").start();
-    await taskOps.deleteTask(taskId);
+    await taskOps.deleteTask(taskId2);
     spinner.succeed(chalk9.green("Task deleted!"));
     console.log(chalk9.gray(`
 \u2717 ${taskTitle}
@@ -1384,10 +1708,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();
@@ -1446,17 +1770,17 @@ import { Command as Command10 } from "commander";
 import chalk11 from "chalk";
 import ora7 from "ora";
 import fs from "fs/promises";
-import path from "path";
+import path2 from "path";
 function getVibetasksHooksPath() {
-  const cliRoot = path.dirname(path.dirname(path.dirname(new URL(import.meta.url).pathname)));
+  const cliRoot = path2.dirname(path2.dirname(path2.dirname(new URL(import.meta.url).pathname)));
   const normalizedPath = process.platform === "win32" && cliRoot.startsWith("/") ? cliRoot.slice(1) : cliRoot;
-  return path.join(normalizedPath, "hooks");
+  return path2.join(normalizedPath, "hooks");
 }
 var hooksCommand = new Command10("hooks").description("Manage hooks integration (git and Claude Code)");
 hooksCommand.command("install").description("Install git hooks in current repository").action(async () => {
   const spinner = ora7("Installing git hooks...").start();
   try {
-    const gitDir = path.join(process.cwd(), ".git");
+    const gitDir = path2.join(process.cwd(), ".git");
     try {
       await fs.access(gitDir);
     } catch {
@@ -1464,9 +1788,9 @@ hooksCommand.command("install").description("Install git hooks in current reposi
       console.error(chalk11.gray("\nRun this command from the root of a git repository.\n"));
       process.exit(1);
     }
-    const hooksDir = path.join(gitDir, "hooks");
+    const hooksDir = path2.join(gitDir, "hooks");
     await fs.mkdir(hooksDir, { recursive: true });
-    const postCommitPath = path.join(hooksDir, "post-commit");
+    const postCommitPath = path2.join(hooksDir, "post-commit");
     const hookScript = `#!/bin/sh
 # VibeTasks post-commit hook
 # Automatically updates tasks based on commit messages
@@ -1520,7 +1844,7 @@ hooksCommand.command("claude").description("Generate Claude Code hook configurat
   try {
     const projectPath = options.project || process.cwd();
     const hooksPath = getVibetasksHooksPath();
-    const syncScriptPath = path.join(hooksPath, "sync-todos.js");
+    const syncScriptPath = path2.join(hooksPath, "sync-todos.js");
     const hookConfig = {
       hooks: {
         SubagentStop: [
@@ -1539,9 +1863,9 @@ hooksCommand.command("claude").description("Generate Claude Code hook configurat
       console.log(JSON.stringify(hookConfig, null, 2));
       process.exit(0);
     }
-    const claudeDir = path.join(projectPath, ".claude");
+    const claudeDir = path2.join(projectPath, ".claude");
     await fs.mkdir(claudeDir, { recursive: true });
-    const settingsPath = path.join(claudeDir, "settings.json");
+    const settingsPath = path2.join(claudeDir, "settings.json");
     let existingSettings = {};
     try {
       const data = await fs.readFile(settingsPath, "utf-8");
@@ -1586,8 +1910,8 @@ Error: ${error.message}
 });
 hooksCommand.command("status").description("Show status of installed hooks").action(async () => {
   console.log(chalk11.blue.bold("\n  VibeTasks Hooks Status\n"));
-  const gitHooksDir = path.join(process.cwd(), ".git", "hooks");
-  const postCommitPath = path.join(gitHooksDir, "post-commit");
+  const gitHooksDir = path2.join(process.cwd(), ".git", "hooks");
+  const postCommitPath = path2.join(gitHooksDir, "post-commit");
   try {
     const content = await fs.readFile(postCommitPath, "utf-8");
     if (content.includes("vibetasks") || content.includes("VibeTasks")) {
@@ -1598,7 +1922,7 @@ hooksCommand.command("status").description("Show status of installed hooks").act
   } catch {
     console.log(chalk11.gray("  [ ] Git post-commit hook not installed"));
   }
-  const claudeSettingsPath = path.join(process.cwd(), ".claude", "settings.json");
+  const claudeSettingsPath = path2.join(process.cwd(), ".claude", "settings.json");
   try {
     const content = await fs.readFile(claudeSettingsPath, "utf-8");
     const settings = JSON.parse(content);
@@ -1621,12 +1945,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) {
@@ -1686,12 +2010,12 @@ import inquirer4 from "inquirer";
 import ora9 from "ora";
 import chalk13 from "chalk";
 import fs2 from "fs/promises";
-import path2 from "path";
+import path3 from "path";
 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";
@@ -1728,12 +2052,12 @@ async function getAvailablePort2(startPort = 3737) {
   });
 }
 function getClaudeConfigPath() {
-  const configHome = process.env.XDG_CONFIG_HOME || path2.join(os.homedir(), ".config");
-  return path2.join(configHome, "claude-code", "config.json");
+  const configHome = process.env.XDG_CONFIG_HOME || path3.join(os.homedir(), ".config");
+  return path3.join(configHome, "claude-code", "config.json");
 }
 async function claudeCodeConfigExists() {
   try {
-    const configDir = path2.dirname(getClaudeConfigPath());
+    const configDir = path3.dirname(getClaudeConfigPath());
     await fs2.access(configDir);
     return true;
   } catch {
@@ -1756,7 +2080,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;
@@ -1800,7 +2124,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);
@@ -1893,7 +2217,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({
@@ -1948,7 +2272,7 @@ async function stepClaudeCodeConfig() {
   const spinner = ora9("Configuring Claude Code...").start();
   try {
     const configPath = getClaudeConfigPath();
-    const configDir = path2.dirname(configPath);
+    const configDir = path3.dirname(configPath);
     await fs2.mkdir(configDir, { recursive: true });
     let config = {};
     try {
@@ -2042,7 +2366,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 };
@@ -2059,7 +2383,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;
@@ -2197,7 +2521,7 @@ async function runNonInteractiveSetup() {
   }
   console.log(chalk13.gray("\nConfiguring Claude Code MCP server..."));
   const configPath = getClaudeConfigPath();
-  const configDir = path2.dirname(configPath);
+  const configDir = path3.dirname(configPath);
   try {
     await fs2.mkdir(configDir, { recursive: true });
     let config = {};
@@ -2232,7 +2556,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)`);
@@ -2303,7 +2627,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) => {
@@ -2317,7 +2641,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")) {
@@ -2527,11 +2851,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";
-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) => {
+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 (taskId2, 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...");
@@ -2577,7 +2901,7 @@ Restored: ${task2.title}`));
 `));
       process.exit(0);
     }
-    if (options.pick || !taskId) {
+    if (options.pick || !taskId2) {
       const allTasks = await taskOps.getTasks("completed");
       if (allTasks.length === 0) {
         console.log(chalk15.yellow("\nNo completed tasks to archive. Complete some tasks first!\n"));
@@ -2592,16 +2916,16 @@ Restored: ${task2.title}`));
           value: t.id
         }))
       }]);
-      taskId = selectedTask;
+      taskId2 = selectedTask;
     }
-    if (!taskId) {
+    if (!taskId2) {
       console.log(chalk15.yellow("\nUsage: vibetasks archive <task-id>"));
       console.log(chalk15.gray("  or: vibetasks archive --pick"));
       console.log(chalk15.gray("  or: vibetasks archive --list"));
       console.log(chalk15.gray("  or: vibetasks archive --unarchive <id>\n"));
       process.exit(1);
     }
-    const validTaskId = taskId;
+    const validTaskId = taskId2;
     spinner.start("Archiving task...");
     let targetId = validTaskId;
     if (validTaskId.length < 32) {
@@ -2610,7 +2934,7 @@ Restored: ${task2.title}`));
       if (!matchingTask) {
         spinner.fail(chalk15.red("Task not found"));
         console.error(chalk15.gray(`
-No task found with ID starting with: ${taskId}
+No task found with ID starting with: ${taskId2}
 `));
         process.exit(1);
       }
@@ -2643,13 +2967,13 @@ Error: ${error.message}
 import { Command as Command15 } from "commander";
 import chalk16 from "chalk";
 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 { spawn as spawn2 } from "child_process";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+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);
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname3 = path4.dirname(__filename2);
 var daemonCommand = new Command15("daemon").description("Manage the VibeTasks error capture daemon").addCommand(createStartCommand()).addCommand(createStopCommand()).addCommand(createStatusCommand()).addCommand(createConfigureCommand()).addCommand(createCaptureCommand());
 function createStartCommand() {
   return new Command15("start").description("Start the error capture daemon").option("-f, --foreground", "Run in foreground (useful for debugging)").option("--no-notify", "Disable startup notification").action(async (options) => {
@@ -2849,8 +3173,8 @@ function createCaptureCommand() {
   });
 }
 async function startDaemonBackground(config) {
-  const workerPath = path3.resolve(__dirname2, "..", "daemon-worker.js");
-  const child = spawn(process.execPath, [workerPath], {
+  const workerPath = path4.resolve(__dirname3, "..", "daemon-worker.js");
+  const child = spawn2(process.execPath, [workerPath], {
     detached: true,
     stdio: "ignore",
     env: {
@@ -2970,7 +3294,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);
@@ -3033,11 +3357,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);
@@ -3198,7 +3522,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) {
@@ -3206,10 +3530,51 @@ 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);
+    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.gray("Summary:"), 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(
@@ -3235,7 +3600,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);
@@ -3249,6 +3614,48 @@ 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)"));
+    }
+  })
+).addCommand(
+  new Command17("compress").description("Compress session history to reduce context usage").option("--dry-run", "Show what would be compressed without making changes").action(async (options) => {
+    const sessionManager2 = getSessionManager();
+    const session = await sessionManager2.getCurrentSession();
+    if (!session) {
+      console.log(chalk18.yellow("No active session to compress"));
+      return;
+    }
+    console.log(chalk18.cyan("Compressing session:"), chalk18.bold(session.id));
+    console.log(chalk18.gray(`Current actions: ${session.actions.length}`));
+    if (options.dryRun) {
+      console.log(chalk18.yellow("DRY RUN - No changes will be made"));
+      console.log();
+      console.log(chalk18.cyan("Compression would:"));
+      console.log(chalk18.gray("  \u2022 Summarize completed subtasks"));
+      console.log(chalk18.gray("  \u2022 Remove redundant action logs"));
+      console.log(chalk18.gray("  \u2022 Preserve critical decisions and blockers"));
+      console.log(chalk18.gray("  \u2022 Maintain active task context"));
+      console.log();
+      console.log(chalk18.white("Estimated reduction: 60-80% of context size"));
+      return;
+    }
+    console.log(chalk18.yellow("\u26A0 Compression not yet implemented"));
+    console.log(chalk18.gray("This feature will be available in the next version"));
+  })
 );
 function formatDuration(start, end) {
   const ms = new Date(end).getTime() - new Date(start).getTime();
@@ -3264,7 +3671,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) {
@@ -3306,23 +3713,11 @@ 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);
-    if (taskId.length < 32) {
-      const allTasks = await taskOps.getTasks("all");
-      const matchingTask = allTasks.find((t) => t.id.startsWith(taskId));
-      if (!matchingTask) {
-        spinner.fail(chalk19.red("Task not found"));
-        console.error(chalk19.gray(`
-No task found with ID: ${taskIdArg}
-`));
-        process.exit(1);
-      }
-      taskId = matchingTask.id;
-    }
-    const task = await taskOps.getTask(taskId);
+    let taskId2 = await shortIdManager.resolveId(taskIdArg, taskOps);
+    const task = await taskOps.getTask(taskId2);
     const subtasks = task.subtasks_json || [];
     spinner.stop();
     console.log();
@@ -3354,23 +3749,11 @@ 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);
-    if (taskId.length < 32) {
-      const allTasks = await taskOps.getTasks("all");
-      const matchingTask = allTasks.find((t) => t.id.startsWith(taskId));
-      if (!matchingTask) {
-        spinner.fail(chalk19.red("Task not found"));
-        console.error(chalk19.gray(`
-No task found with ID: ${taskIdArg}
-`));
-        process.exit(1);
-      }
-      taskId = matchingTask.id;
-    }
-    const task = await taskOps.getTask(taskId);
+    let taskId2 = await shortIdManager.resolveId(taskIdArg, taskOps);
+    const task = await taskOps.getTask(taskId2);
     const subtasks = [...task.subtasks_json || []];
     if (subtasks.length === 0) {
       spinner.fail(chalk19.yellow("No subtasks to update"));
@@ -3404,7 +3787,7 @@ Valid range: 1-${subtasks.length}
       spinner.succeed(chalk19.yellow("All specified subtasks were already done"));
       process.exit(0);
     }
-    await taskOps.updateTask(taskId, { subtasks_json: subtasks });
+    await taskOps.updateTask(taskId2, { subtasks_json: subtasks });
     const doneCount = subtasks.filter((s) => s.done).length;
     spinner.succeed(chalk19.green(`Marked ${updated.length} subtask(s) as done`));
     console.log();
@@ -3415,7 +3798,7 @@ Valid range: 1-${subtasks.length}
     console.log(chalk19.gray(`Progress: ${doneCount}/${subtasks.length} completed`));
     if (doneCount === subtasks.length) {
       console.log();
-      console.log(chalk19.cyan(`All subtasks complete! Run: vibetasks done ${taskId.substring(0, 8)}`));
+      console.log(chalk19.cyan(`All subtasks complete! Run: vibetasks done ${taskId2.substring(0, 8)}`));
     }
     console.log();
     process.exit(0);
@@ -3430,23 +3813,11 @@ 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);
-    if (taskId.length < 32) {
-      const allTasks = await taskOps.getTasks("all");
-      const matchingTask = allTasks.find((t) => t.id.startsWith(taskId));
-      if (!matchingTask) {
-        spinner.fail(chalk19.red("Task not found"));
-        console.error(chalk19.gray(`
-No task found with ID: ${taskIdArg}
-`));
-        process.exit(1);
-      }
-      taskId = matchingTask.id;
-    }
-    const task = await taskOps.getTask(taskId);
+    let taskId2 = await shortIdManager.resolveId(taskIdArg, taskOps);
+    const task = await taskOps.getTask(taskId2);
     const subtasks = [...task.subtasks_json || []];
     if (subtasks.length === 0) {
       spinner.fail(chalk19.yellow("No subtasks to update"));
@@ -3480,7 +3851,7 @@ Valid range: 1-${subtasks.length}
       spinner.succeed(chalk19.yellow("All specified subtasks were already incomplete"));
       process.exit(0);
     }
-    await taskOps.updateTask(taskId, { subtasks_json: subtasks });
+    await taskOps.updateTask(taskId2, { subtasks_json: subtasks });
     const doneCount = subtasks.filter((s) => s.done).length;
     spinner.succeed(chalk19.yellow(`Marked ${updated.length} subtask(s) as incomplete`));
     console.log();
@@ -3504,7 +3875,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,
@@ -3602,7 +3973,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)}`;
@@ -3642,7 +4013,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 },
@@ -3669,7 +4040,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) {
@@ -3778,7 +4149,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");
@@ -3834,10 +4205,2650 @@ Error: ${error.message}
 });
 inboxCommand.addCommand(inboxStatsCommand);
 
+// src/commands/handoff.ts
+import { Command as Command21 } from "commander";
+import chalk22 from "chalk";
+import { randomUUID as randomUUID3 } from "crypto";
+import { AuthManager as AuthManager20, TaskOperations as TaskOperations16 } from "@vibetasks/core";
+function extractDecisions(session) {
+  if (!session?.actions) return [];
+  const decisions = [];
+  const decisionKeywords = ["decided", "choosing", "using", "approach", "instead of", "because", "opted for"];
+  for (const action of session.actions) {
+    const desc = action.description.toLowerCase();
+    const hasDecisionKeyword = decisionKeywords.some((kw) => desc.includes(kw));
+    if (hasDecisionKeyword || action.type === "note") {
+      const sentences = action.description.split(/[.!?]\s+/);
+      const decision = sentences[0];
+      const rationale = sentences.slice(1).join(". ");
+      decisions.push({
+        decision,
+        rationale: rationale || "See session history for context",
+        timestamp: action.timestamp
+      });
+    }
+  }
+  return decisions.slice(-10);
+}
+function extractModifiedFiles(session) {
+  if (!session?.actions) return [];
+  const fileMap = /* @__PURE__ */ new Map();
+  for (const action of session.actions) {
+    if (action.type === "file_modified" && action.filePath) {
+      fileMap.set(action.filePath, (fileMap.get(action.filePath) || 0) + 1);
+    }
+  }
+  const files = Array.from(fileMap.entries()).sort((a, b) => b[1] - a[1]).map(([path6, count]) => ({
+    path: path6,
+    relevance: count >= 5 ? "critical" : count >= 2 ? "important" : "reference"
+  }));
+  return files.slice(0, 20);
+}
+async function generateStructuredHandoff(sessionManager2, includeFull) {
+  const session = await sessionManager2.getCurrentSession();
+  const authManager = new AuthManager20();
+  const taskOps = await TaskOperations16.fromAuthManager(authManager);
+  const allTasks = await taskOps.getTasks("all");
+  const vibingTasks = allTasks.filter((t) => t.status === "vibing");
+  const completed = [];
+  const nextSteps = [];
+  const blockers = [];
+  const taskIds = [];
+  let intent = "Continue working on vibing tasks";
+  let inProgress = "";
+  for (const task of vibingTasks) {
+    taskIds.push(task.id);
+    const contextNotes = task.context_notes || "";
+    const intentMatch = contextNotes.match(/INTENT:\s*(.+?)(?:\n|$)/i);
+    if (intentMatch) {
+      intent = intentMatch[1].trim();
+    } else {
+      intent = task.title;
+    }
+    const doneMatch = contextNotes.match(/DONE:\s*(.+?)(?:\n(?:CURRENT|NEXT|BLOCKED)|$)/is);
+    if (doneMatch) {
+      completed.push(doneMatch[1].trim());
+    }
+    const currentMatch = contextNotes.match(/CURRENT:\s*(.+?)(?:\n(?:NEXT|BLOCKED)|$)/is);
+    if (currentMatch) {
+      inProgress = currentMatch[1].trim();
+    }
+    const nextMatch = contextNotes.match(/NEXT:\s*(.+?)(?:\n(?:BLOCKED)|$)/is);
+    if (nextMatch) {
+      nextSteps.push(nextMatch[1].trim());
+    }
+    const blockedMatch = contextNotes.match(/BLOCKED:\s*(.+?)$/is);
+    if (blockedMatch && blockedMatch[1].trim() !== "None") {
+      blockers.push({
+        type: "external",
+        description: blockedMatch[1].trim(),
+        context: `Task: ${task.title}`
+      });
+    }
+    const subtasks = task.subtasks_json || task.subtasks || [];
+    subtasks.forEach((s) => {
+      if (s.done) {
+        completed.push(s.title);
+      } else if (!inProgress) {
+        inProgress = s.title;
+      } else {
+        nextSteps.push(s.title);
+      }
+    });
+  }
+  let gitBranch;
+  let uncommittedFiles = [];
+  try {
+    const { execSync: execSync3 } = await import("child_process");
+    gitBranch = execSync3("git branch --show-current", { encoding: "utf-8", timeout: 2e3 }).trim();
+    const gitStatus = execSync3("git status --porcelain", { encoding: "utf-8", timeout: 2e3 }).trim();
+    uncommittedFiles = gitStatus.split("\n").filter(Boolean);
+  } catch {
+  }
+  const handoff = {
+    intent,
+    progress: {
+      completed: completed.slice(0, 10),
+      // Limit to 10 for token efficiency
+      in_progress: inProgress || "No current work in progress",
+      next_steps: nextSteps.slice(0, 5)
+      // Limit to 5 next steps
+    },
+    state: {
+      git_branch: gitBranch,
+      uncommitted_files: uncommittedFiles.slice(0, 20)
+      // Limit to 20 files
+    },
+    decisions: extractDecisions(session),
+    blockers,
+    files: extractModifiedFiles(session),
+    sessionId: session?.id || "unknown",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    taskIds
+  };
+  return handoff;
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+async function generateA2AHandoff(sessionManager2, options = {}) {
+  const maxTokens = options.maxTokens || 1e4;
+  let estimatedTokens = 0;
+  const authManager = new AuthManager20();
+  const taskOps = await TaskOperations16.fromAuthManager(authManager);
+  const allTasks = await taskOps.getTasks("all");
+  const vibingTasks = allTasks.filter((t) => t.status === "vibing");
+  const tier1Tasks = vibingTasks.slice(0, 3).map((task) => ({
+    id: task.id,
+    a2a_task_id: task.a2a_task_id,
+    title: task.title,
+    status: task.status || "vibing",
+    semantic_vector_id: task.semantic_vector_id,
+    last_update: task.updated_at || task.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+    priority: task.priority,
+    subtasks: task.subtasks_json || task.subtasks || []
+  }));
+  const tier1Json = JSON.stringify(tier1Tasks);
+  estimatedTokens += estimateTokens(tier1Json);
+  let handoff_notes = "";
+  const tools_used = [];
+  const decision_tree = [];
+  const blockers = [];
+  const next_actions = [];
+  for (const task of vibingTasks.slice(0, 3)) {
+    const contextNotes = task.context_notes || "";
+    const intentMatch = contextNotes.match(/INTENT:\s*(.+?)(?:\n|$)/i);
+    if (intentMatch) {
+      handoff_notes = intentMatch[1].trim();
+    }
+    const doneMatch = contextNotes.match(/DONE:\s*(.+?)(?:\n(?:CURRENT|NEXT|BLOCKED)|$)/is);
+    if (doneMatch) {
+      decision_tree.push({
+        decision: "Completed",
+        reasoning: doneMatch[1].trim()
+      });
+    }
+    const nextMatch = contextNotes.match(/NEXT:\s*(.+?)(?:\n(?:BLOCKED)|$)/is);
+    if (nextMatch) {
+      next_actions.push(nextMatch[1].trim());
+    }
+    const blockedMatch = contextNotes.match(/BLOCKED:\s*(.+?)$/is);
+    if (blockedMatch && blockedMatch[1].trim() !== "None") {
+      blockers.push({
+        type: "external",
+        description: blockedMatch[1].trim(),
+        context: `Task: ${task.title}`
+      });
+    }
+  }
+  handoff_notes = handoff_notes || "Continue working on vibing tasks";
+  const context_summary = handoff_notes;
+  estimatedTokens += estimateTokens(JSON.stringify({ handoff_notes, context_summary, decision_tree, blockers, next_actions }));
+  let uncommittedFiles = [];
+  let gitBranch;
+  if (estimatedTokens < maxTokens * 0.7) {
+    try {
+      const { execSync: execSync3 } = await import("child_process");
+      gitBranch = execSync3("git branch --show-current", { encoding: "utf-8", timeout: 2e3 }).trim();
+      const gitStatus = execSync3("git status --porcelain", { encoding: "utf-8", timeout: 2e3 }).trim();
+      uncommittedFiles = gitStatus.split("\n").filter(Boolean).slice(0, 20);
+      estimatedTokens += estimateTokens(JSON.stringify({ git_branch: gitBranch, uncommitted_files: uncommittedFiles }));
+    } catch {
+    }
+  }
+  const session = await sessionManager2.getCurrentSession();
+  const sessionId = session?.id || "unknown";
+  const executionContext = {
+    tools_used,
+    decision_tree,
+    blockers,
+    next_actions
+  };
+  const resourceRequirements = {
+    capabilities: ["code_generation", "task_management"],
+    estimated_time_minutes: vibingTasks.length * 15,
+    // Rough estimate: 15 min per task
+    priority: vibingTasks.some((t) => t.priority === "high") ? "high" : "medium"
+  };
+  const handoffId = randomUUID3();
+  const a2aRequest = {
+    jsonrpc: "2.0",
+    method: "vibetasks.handoff",
+    params: {
+      handoff_type: "continue",
+      tasks: tier1Tasks,
+      handoff_notes,
+      context_summary,
+      execution_context: executionContext,
+      resource_requirements: resourceRequirements,
+      semantic_context_ids: tier1Tasks.map((t) => t.semantic_vector_id).filter(Boolean),
+      workspace_id: options.workspaceId,
+      source_session_id: sessionId
+    },
+    id: handoffId
+  };
+  estimatedTokens = estimateTokens(JSON.stringify(a2aRequest));
+  return {
+    request: a2aRequest,
+    estimatedTokens
+  };
+}
+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").option("--json", "Output as structured JSON (HandoffContext format)").option("--a2a", "Output as A2A JSON-RPC 2.0 format (for agent-to-agent handoffs)").option("--max-tokens <number>", "Maximum tokens for A2A handoff (default: 10000)", parseInt).option("--workspace-id <id>", "Workspace ID for A2A task IDs").option("--save", "Save handoff to .vibebot/handoffs/").option("--auto-update-context", "Automatically update current vibing task context notes").action(async (sessionId, options) => {
+  const sessionManager2 = getSessionManager();
+  if (sessionId && !options?.json) {
+    const handoff = await sessionManager2.getSessionHandoff(sessionId);
+    console.log(handoff);
+    return;
+  }
+  if (options?.a2a) {
+    try {
+      const { request, estimatedTokens } = await generateA2AHandoff(sessionManager2, {
+        maxTokens: options?.maxTokens,
+        workspaceId: options?.workspaceId
+      });
+      if (options?.save) {
+        const fs4 = await import("fs/promises");
+        const path6 = await import("path");
+        const handoffDir = path6.join(process.cwd(), ".vibebot", "handoffs");
+        await fs4.mkdir(handoffDir, { recursive: true });
+        const filename = `a2a_${request.id}.json`;
+        const filepath = path6.join(handoffDir, filename);
+        await fs4.writeFile(filepath, JSON.stringify(request, null, 2));
+        console.error(chalk22.green("\u2713 A2A handoff saved:"), chalk22.gray(filepath));
+        console.error(chalk22.gray(`  Estimated tokens: ${estimatedTokens}`));
+      }
+      console.log(JSON.stringify(request, null, 2));
+      if (!options?.save) {
+        console.error(chalk22.gray(`
+# Estimated tokens: ${estimatedTokens}`));
+      }
+      return;
+    } catch (error) {
+      console.error(chalk22.red("Error generating A2A handoff:"), error);
+      process.exit(1);
+    }
+  }
+  if (options?.json || options?.save) {
+    try {
+      const handoffData = await generateStructuredHandoff(sessionManager2, options?.full);
+      if (options?.save) {
+        const fs4 = await import("fs/promises");
+        const path6 = await import("path");
+        const handoffDir = path6.join(process.cwd(), ".vibebot", "handoffs");
+        await fs4.mkdir(handoffDir, { recursive: true });
+        const filename = `${handoffData.sessionId}_${(/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/:/g, "-")}.json`;
+        const filepath = path6.join(handoffDir, filename);
+        await fs4.writeFile(filepath, JSON.stringify(handoffData, null, 2));
+        console.log(chalk22.green("\u2713 Handoff saved:"), chalk22.gray(filepath));
+      }
+      if (options?.json) {
+        console.log(JSON.stringify(handoffData, null, 2));
+      }
+      return;
+    } catch (error) {
+      console.error(chalk22.red("Error generating handoff:"), error);
+      process.exit(1);
+    }
+  }
+  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: execSync3 } = await import("child_process");
+    const gitStatus = execSync3("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 = execSync3("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 randomUUID4 } 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: randomUUID4(),
+      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 as execSync2 } 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 (taskId2, options) => {
+  try {
+    const authManager = new AuthManager22();
+    const taskOps = await TaskOperations18.fromAuthManager(authManager);
+    const sessionManager2 = getSessionManager();
+    let task;
+    if (taskId2) {
+      const allTasks = await taskOps.getTasks("all");
+      task = allTasks.find(
+        (t) => t.id.startsWith(taskId2) || t.short_id?.toString() === taskId2
+      );
+      if (!task) {
+        console.error(chalk24.red(`Task not found: ${taskId2}`));
+        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 = execSync2("git branch --show-current", { encoding: "utf-8" }).trim();
+    parts.push(`Branch: ${branch}`);
+    const status = execSync2("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 = execSync2("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").option("--source <name>", "Filter by source: sentry, github, slack, email, ai, human").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 taskId2 = taskArg;
+    if (/^\d+$/.test(taskArg)) {
+      const shortIdManager = new ShortIdManager();
+      const resolved = await shortIdManager.resolveId(taskArg);
+      if (resolved) {
+        taskId2 = 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(taskId2);
+    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());
+    }
+    let changes = await taskOps.getTaskChanges(taskId2, queryOptions);
+    if (options.source) {
+      const source = options.source.toLowerCase();
+      changes = changes.filter((c) => {
+        const msg = c.message || "";
+        switch (source) {
+          case "sentry":
+            return msg.startsWith("[Sentry]");
+          case "github":
+            return msg.startsWith("[GitHub]");
+          case "slack":
+            return msg.startsWith("[Slack]");
+          case "email":
+            return msg.startsWith("[Email]");
+          case "ai":
+            return c.actor_type === "ai";
+          case "human":
+            return c.actor_type === "human";
+          case "integration":
+          case "integrations":
+            return msg.startsWith("[Sentry]") || msg.startsWith("[GitHub]") || msg.startsWith("[Slack]") || msg.startsWith("[Email]");
+          default:
+            return true;
+        }
+      });
+    }
+    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: ${taskId2}`));
+    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;
+  let actorIcon;
+  const message = change.message || "";
+  if (message.startsWith("[Sentry]")) {
+    actorIcon = "\u{1F534}";
+  } else if (message.startsWith("[GitHub]")) {
+    actorIcon = "\u{1F419}";
+  } else if (message.startsWith("[Slack]")) {
+    actorIcon = "\u{1F4AC}";
+  } else if (message.startsWith("[Email]")) {
+    actorIcon = "\u{1F4E7}";
+  } else if (change.actor_type === "ai") {
+    actorIcon = "\u{1F916}";
+  } else if (change.actor_type === "human") {
+    actorIcon = "\u{1F464}";
+  } else {
+    actorIcon = "\u2699\uFE0F";
+  }
+  if (oneline) {
+    const message2 = change.message || change.change_type;
+    console.log(
+      `${chalk25.yellow(changeId)} ${chalk25.gray(dateStr)} ${colorFn(change.change_type.padEnd(16))} ${actorIcon} ${message2}`
+    );
+  } else {
+    console.log(chalk25.yellow(`change ${change.id}`));
+    let actorDisplay = `${actorIcon} ${change.actor_type}`;
+    if (message.startsWith("[Sentry]")) {
+      actorDisplay = `${actorIcon} sentry`;
+    } else if (message.startsWith("[GitHub]")) {
+      actorDisplay = `${actorIcon} github`;
+    } else if (message.startsWith("[Slack]")) {
+      actorDisplay = `${actorIcon} slack`;
+    } else if (message.startsWith("[Email]")) {
+      actorDisplay = `${actorIcon} email`;
+    }
+    console.log(`Actor:  ${actorDisplay}`);
+    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 taskId2 = taskArg;
+    if (/^\d+$/.test(taskArg)) {
+      const shortIdManager = new ShortIdManager();
+      const resolved = await shortIdManager.resolveId(taskArg);
+      if (resolved) {
+        taskId2 = 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);
+      }
+      taskId2 = matchingTask.id;
+    }
+    const task = await taskOps.getTask(taskId2);
+    if (task.status === "paused") {
+      console.log(chalk27.yellow(`
+Task is already paused: ${task.title}
+`));
+      console.log(chalk27.gray("Resume with: vibetasks resume " + taskId2.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(taskId2, 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 ${taskId2.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 taskId2;
+    if (!taskArg) {
+      if (pausedTasks.length === 1) {
+        taskId2 = 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
+          }))
+        }]);
+        taskId2 = selectedTask;
+      }
+    } else {
+      taskId2 = taskArg;
+      if (/^\d+$/.test(taskArg)) {
+        const shortIdManager = new ShortIdManager();
+        const resolved = await shortIdManager.resolveId(taskArg);
+        if (resolved) {
+          taskId2 = 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);
+        }
+        taskId2 = matchingTask.id;
+      }
+    }
+    const task = await taskOps.getTask(taskId2);
+    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 " + taskId2.slice(0, 8) + "\n"));
+      }
+      process.exit(0);
+    }
+    spinner.start("Resuming task...");
+    const resumedTask = await taskOps.resumeTask(taskId2);
+    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 ${taskId2.slice(0, 8)}`));
+    console.log(chalk28.gray(`Pause again:   vibetasks pause ${taskId2.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 taskId2;
+      if (options.task) {
+        if (/^\d+$/.test(options.task)) {
+          const shortIdManager = new ShortIdManager();
+          const resolved = await shortIdManager.resolveId(options.task);
+          if (resolved) {
+            taskId2 = 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) {
+            taskId2 = matchingTask.id;
+          }
+        } else {
+          taskId2 = options.task;
+        }
+      }
+      if (!taskId2) {
+        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(taskId2, { limit: 20 });
+      const task2 = await taskOps.getTask(taskId2);
+      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 taskId2 = taskArg;
+    if (/^\d+$/.test(taskArg)) {
+      const shortIdManager = new ShortIdManager();
+      const resolved = await shortIdManager.resolveId(taskArg);
+      if (resolved) {
+        taskId2 = 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);
+      }
+      taskId2 = matchingTask.id;
+    }
+    const task = await taskOps.getTask(taskId2);
+    const changes = await taskOps.getTaskChanges(taskId2, { 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: ${taskId2}`));
+    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 ${taskId2.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;
+}
+
+// src/commands/research.ts
+import { Command as Command30 } from "commander";
+import chalk31 from "chalk";
+import Table4 from "cli-table3";
+var researchCommand = new Command30("research").description("Manage research documents").action(() => {
+  researchCommand.outputHelp();
+});
+researchCommand.command("list").alias("ls").description("List saved research documents").option("-p, --project <project>", "Filter by project").option("-s, --search <query>", "Search research docs").option("-l, --limit <number>", "Limit results", "20").action(async (options) => {
+  try {
+    const response = await fetch(`${process.env.VIBETASKS_API_URL || "http://localhost:3847"}/api/workspace-docs?` + new URLSearchParams({
+      doc_type: "research",
+      ...options.project && { project: options.project },
+      ...options.search && { search: options.search },
+      limit: options.limit
+    }), {
+      headers: {
+        "Authorization": `Bearer ${process.env.VIBETASKS_AUTH_TOKEN}`
+      }
+    });
+    if (!response.ok) {
+      throw new Error("Failed to fetch research docs");
+    }
+    const data = await response.json();
+    const docs = data.docs || [];
+    if (docs.length === 0) {
+      console.log(chalk31.yellow("\n\u{1F4DA} No research documents found.\n"));
+      console.log(chalk31.dim("Use the MCP tool capture_research() to save research findings."));
+      return;
+    }
+    console.log(chalk31.bold(`
+\u{1F4DA} Research Documents (${docs.length})
+`));
+    const table = new Table4({
+      head: [
+        chalk31.cyan("#"),
+        chalk31.cyan("Title"),
+        chalk31.cyan("Project"),
+        chalk31.cyan("Sources"),
+        chalk31.cyan("Created")
+      ],
+      colWidths: [5, 40, 20, 10, 12],
+      wordWrap: true
+    });
+    docs.forEach((doc, idx) => {
+      const date = new Date(doc.created_at).toLocaleDateString();
+      const sourceCount = doc.source_urls?.length || 0;
+      table.push([
+        idx + 1,
+        doc.title,
+        doc.project_tag || "none",
+        sourceCount > 0 ? chalk31.green(sourceCount) : chalk31.dim("-"),
+        date
+      ]);
+    });
+    console.log(table.toString());
+    console.log(chalk31.dim("\nUse: vibetasks research show <number> to view details\n"));
+  } catch (error) {
+    console.error(chalk31.red(`\u2717 Error: ${error.message}`));
+    process.exit(1);
+  }
+});
+researchCommand.command("show <id>").description("Show research document details").action(async (id) => {
+  try {
+    let docId = id;
+    if (/^\d+$/.test(id)) {
+      const response2 = await fetch(`${process.env.VIBETASKS_API_URL || "http://localhost:3847"}/api/workspace-docs?` + new URLSearchParams({
+        doc_type: "research",
+        limit: "100"
+      }), {
+        headers: {
+          "Authorization": `Bearer ${process.env.VIBETASKS_AUTH_TOKEN}`
+        }
+      });
+      const data2 = await response2.json();
+      const docs = data2.docs || [];
+      const idx = parseInt(id) - 1;
+      if (idx < 0 || idx >= docs.length) {
+        console.error(chalk31.red(`\u2717 Research doc #${id} not found`));
+        process.exit(1);
+      }
+      docId = docs[idx].id;
+    }
+    const response = await fetch(`${process.env.VIBETASKS_API_URL || "http://localhost:3847"}/api/workspace-docs/${docId}`, {
+      headers: {
+        "Authorization": `Bearer ${process.env.VIBETASKS_AUTH_TOKEN}`
+      }
+    });
+    if (!response.ok) {
+      throw new Error("Failed to fetch research doc");
+    }
+    const data = await response.json();
+    const doc = data.doc;
+    console.log(chalk31.bold(`
+\u{1F4DA} ${doc.title}
+`));
+    console.log(chalk31.dim("\u2500".repeat(80)));
+    console.log(chalk31.cyan("Project:"), doc.project_tag || "none");
+    console.log(chalk31.cyan("Created:"), new Date(doc.created_at).toLocaleString());
+    console.log(chalk31.cyan("Created by:"), doc.created_by);
+    if (doc.source_urls && doc.source_urls.length > 0) {
+      console.log(chalk31.cyan("\nSources:"));
+      doc.source_urls.forEach((url, idx) => {
+        console.log(chalk31.dim(`  ${idx + 1}. ${url}`));
+      });
+    }
+    if (doc.search_queries && doc.search_queries.length > 0) {
+      console.log(chalk31.cyan("\nSearch Queries:"));
+      doc.search_queries.forEach((query) => {
+        console.log(chalk31.dim(`  \u2022 ${query}`));
+      });
+    }
+    console.log(chalk31.cyan("\nContent:"));
+    console.log(chalk31.dim("\u2500".repeat(80)));
+    console.log(doc.content);
+    console.log(chalk31.dim("\u2500".repeat(80) + "\n"));
+  } catch (error) {
+    console.error(chalk31.red(`\u2717 Error: ${error.message}`));
+    process.exit(1);
+  }
+});
+
+// src/commands/bundle.ts
+import { Command as Command31 } from "commander";
+import chalk32 from "chalk";
+import ora19 from "ora";
+import {
+  installBundle,
+  removeBundle,
+  updateBundle,
+  activateBundle,
+  deactivateBundle,
+  loadInstalledBundles,
+  loadBundleFromDirectory,
+  getGlobalBundlesDir,
+  getActiveBundle,
+  getRequiredScaffoldVariables
+} from "@vibetasks/ralph-engine";
+import * as path5 from "path";
+import * as fs3 from "fs";
+var _inquirer = null;
+var _readline = null;
+async function getInquirer() {
+  if (_inquirer === null) {
+    try {
+      _inquirer = (await import("inquirer")).default;
+    } catch {
+      _inquirer = false;
+    }
+  }
+  return _inquirer;
+}
+async function getReadline() {
+  if (_readline === null) {
+    _readline = await import("readline");
+  }
+  return _readline;
+}
+async function promptFn(message) {
+  const inquirer9 = await getInquirer();
+  if (inquirer9) {
+    const answers = await inquirer9.prompt([{ type: "input", name: "value", message }]);
+    return answers.value;
+  }
+  const readline2 = await getReadline();
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => rl.question(`${message} `, (answer) => {
+    rl.close();
+    resolve(answer);
+  }));
+}
+async function confirmFn(message) {
+  const inquirer9 = await getInquirer();
+  if (inquirer9) {
+    const answers = await inquirer9.prompt([{ type: "confirm", name: "confirm", message, default: true }]);
+    return answers.confirm;
+  }
+  const answer = await promptFn(`${message} (y/n)`);
+  return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+}
+var installCommand = new Command31("install").description("Install a bundle from GitHub or local path").argument("<source>", "Bundle source (github:owner/repo, owner/repo, or local path)").option("-f, --force", "Overwrite if already installed").option("-g, --global", "Install globally (default)", true).option("-p, --project", "Install to current project only").option("-a, --activate", "Activate bundle after installing").action(async (source, options) => {
+  const spinner = ora19(`Installing bundle from ${source}...`).start();
+  try {
+    const target = options.project ? process.cwd() : "global";
+    const result = await installBundle(source, {
+      target,
+      force: options.force,
+      activate: options.activate
+    });
+    if (!result.success) {
+      spinner.fail(chalk32.red(result.error || "Installation failed"));
+      if (result.warnings?.length) {
+        result.warnings.forEach((w) => console.log(chalk32.yellow(`  \u26A0 ${w}`)));
+      }
+      process.exit(1);
+    }
+    spinner.succeed(chalk32.green(`Installed ${result.bundle.manifest.name} v${result.bundle.manifest.version}`));
+    if (result.warnings?.length) {
+      result.warnings.forEach((w) => console.log(chalk32.yellow(`  \u26A0 ${w}`)));
+    }
+    console.log(chalk32.gray(`
+  Path: ${result.installPath}`));
+    console.log(chalk32.gray(`  Blueprints: ${result.bundle.blueprints.length}`));
+    console.log(chalk32.gray(`  Has Studio config: ${result.bundle.studio ? "Yes" : "No"}`));
+    console.log(chalk32.gray(`  Has Scaffold: ${result.bundle.scaffold ? "Yes" : "No"}`));
+    if (options.activate) {
+      console.log(chalk32.green(`
+\u2713 Bundle activated on current project`));
+    } else {
+      console.log(chalk32.blue(`
+To use this bundle: vibetasks bundle use ${result.bundle.manifest.name}`));
+    }
+    process.exit(0);
+  } catch (error) {
+    spinner.fail(chalk32.red("Installation failed"));
+    console.error(chalk32.red(`
+Error: ${error.message}
+`));
+    process.exit(1);
+  }
+});
+var useCommand = new Command31("use").description("Activate a bundle on current project").argument("<name>", "Bundle name").option("-s, --scaffold", "Also apply scaffold template").option("-r, --run-commands", "Run post-scaffold commands").action(async (name, options) => {
+  const spinner = ora19(`Activating bundle ${name}...`).start();
+  try {
+    const projectPath = process.cwd();
+    const bundlePath = path5.join(getGlobalBundlesDir(), name);
+    if (!fs3.existsSync(bundlePath)) {
+      spinner.fail(chalk32.red(`Bundle '${name}' not found`));
+      console.log(chalk32.gray("\nRun `vibetasks bundle list` to see installed bundles"));
+      process.exit(1);
+    }
+    const bundle = await loadBundleFromDirectory(bundlePath, { type: "local", path: bundlePath });
+    let scaffoldVariables = {};
+    if (options.scaffold && bundle.scaffold) {
+      const requiredVars = getRequiredScaffoldVariables(bundle.scaffold);
+      if (requiredVars.length > 0) {
+        spinner.stop();
+        console.log(chalk32.blue("\nScaffold requires the following values:\n"));
+        for (const variable of requiredVars) {
+          const value = await promptFn(`${variable.label}${variable.description ? ` (${variable.description})` : ""}: `);
+          scaffoldVariables[variable.name] = value;
+        }
+        spinner.start("Activating bundle...");
+      }
+    }
+    const result = await activateBundle(name, {
+      projectPath,
+      applyScaffold: options.scaffold,
+      scaffoldVariables,
+      runPostScaffold: options.runCommands
+    });
+    if (!result.success) {
+      spinner.fail(chalk32.red(result.error || "Activation failed"));
+      if (result.warnings?.length) {
+        result.warnings.forEach((w) => console.log(chalk32.yellow(`  \u26A0 ${w}`)));
+      }
+      process.exit(1);
+    }
+    spinner.succeed(chalk32.green(`Activated ${name}`));
+    if (result.files?.length) {
+      console.log(chalk32.gray("\n  Files:"));
+      result.files.forEach((f) => {
+        const icon = f.action === "created" ? "+" : f.action === "modified" ? "~" : "\u25CB";
+        const color = f.action === "created" ? chalk32.green : f.action === "modified" ? chalk32.yellow : chalk32.gray;
+        console.log(color(`    ${icon} ${f.path}`));
+      });
+    }
+    if (result.blueprintsLoaded) {
+      console.log(chalk32.gray(`
+  Blueprints loaded: ${result.blueprintsLoaded.blueprints.length}`));
+    }
+    if (result.commandResults?.length) {
+      console.log(chalk32.gray("\n  Post-scaffold commands:"));
+      result.commandResults.forEach((r) => {
+        const icon = r.success ? "\u2713" : "\u2717";
+        const color = r.success ? chalk32.green : chalk32.red;
+        console.log(color(`    ${icon} ${r.command}`));
+      });
+    }
+    if (result.warnings?.length) {
+      console.log(chalk32.yellow("\n  Warnings:"));
+      result.warnings.forEach((w) => console.log(chalk32.yellow(`    \u26A0 ${w}`)));
+    }
+    console.log(chalk32.blue("\n\u2713 Bundle is now active. VibBot will use its blueprints."));
+    process.exit(0);
+  } catch (error) {
+    spinner.fail(chalk32.red("Activation failed"));
+    console.error(chalk32.red(`
+Error: ${error.message}
+`));
+    process.exit(1);
+  }
+});
+var listCommand2 = new Command31("list").alias("ls").description("List installed bundles").option("-a, --active", "Show only active bundle for current project").action(async (options) => {
+  try {
+    if (options.active) {
+      const activeBundle = await getActiveBundle(process.cwd());
+      if (activeBundle) {
+        console.log(chalk32.green(`
+  Active bundle: ${activeBundle.manifest.name} v${activeBundle.manifest.version}`));
+        console.log(chalk32.gray(`  ${activeBundle.manifest.description}
+`));
+      } else {
+        console.log(chalk32.gray("\n  No active bundle for current project\n"));
+      }
+      process.exit(0);
+    }
+    const { bundles, errors } = await loadInstalledBundles();
+    if (bundles.length === 0) {
+      console.log(chalk32.gray("\n  No bundles installed\n"));
+      console.log(chalk32.blue("  Install a bundle: vibetasks bundle install github:owner/repo\n"));
+      process.exit(0);
+    }
+    console.log(chalk32.white(`
+  Installed Bundles (${bundles.length}):
+`));
+    for (const bundle of bundles) {
+      console.log(chalk32.cyan(`  \u2022 ${bundle.manifest.name}`), chalk32.gray(`v${bundle.manifest.version}`));
+      console.log(chalk32.gray(`    ${bundle.manifest.description}`));
+      console.log(chalk32.gray(`    Blueprints: ${bundle.blueprints.length} | Studio: ${bundle.studio ? "\u2713" : "\u2717"} | Scaffold: ${bundle.scaffold ? "\u2713" : "\u2717"}`));
+      console.log();
+    }
+    if (errors.length > 0) {
+      console.log(chalk32.yellow("  Errors loading some bundles:"));
+      errors.forEach((e) => console.log(chalk32.yellow(`    \u2022 ${e.message}`)));
+      console.log();
+    }
+    process.exit(0);
+  } catch (error) {
+    console.error(chalk32.red(`
+Error: ${error.message}
+`));
+    process.exit(1);
+  }
+});
+var infoCommand = new Command31("info").description("Show detailed information about a bundle").argument("<name>", "Bundle name").action(async (name) => {
+  try {
+    const bundlePath = path5.join(getGlobalBundlesDir(), name);
+    if (!fs3.existsSync(bundlePath)) {
+      console.log(chalk32.red(`
+  Bundle '${name}' not found
+`));
+      process.exit(1);
+    }
+    const bundle = await loadBundleFromDirectory(bundlePath, { type: "local", path: bundlePath });
+    console.log(chalk32.white(`
+  ${bundle.manifest.displayName || bundle.manifest.name}`));
+    console.log(chalk32.gray(`  v${bundle.manifest.version}`));
+    console.log();
+    console.log(chalk32.gray(`  ${bundle.manifest.description}`));
+    console.log();
+    if (bundle.manifest.author) {
+      const author = typeof bundle.manifest.author === "string" ? bundle.manifest.author : bundle.manifest.author.name;
+      console.log(chalk32.gray(`  Author: ${author}`));
+    }
+    if (bundle.manifest.domain) {
+      console.log(chalk32.gray(`  Domain: ${bundle.manifest.domain}`));
+    }
+    if (bundle.manifest.tags?.length) {
+      console.log(chalk32.gray(`  Tags: ${bundle.manifest.tags.join(", ")}`));
+    }
+    if (bundle.manifest.homepage) {
+      console.log(chalk32.gray(`  Homepage: ${bundle.manifest.homepage}`));
+    }
+    if (bundle.manifest.repository) {
+      console.log(chalk32.gray(`  Repository: ${bundle.manifest.repository}`));
+    }
+    console.log();
+    console.log(chalk32.cyan("  Components:"));
+    console.log(chalk32.gray(`    \u2022 Blueprints: ${bundle.blueprints.length}`));
+    if (bundle.blueprints.length > 0) {
+      bundle.blueprints.slice(0, 5).forEach((b) => {
+        console.log(chalk32.gray(`      - ${b.frontmatter.name}: ${b.frontmatter.description}`));
+      });
+      if (bundle.blueprints.length > 5) {
+        console.log(chalk32.gray(`      ... and ${bundle.blueprints.length - 5} more`));
+      }
+    }
+    console.log(chalk32.gray(`    \u2022 Studio config: ${bundle.studio ? "Yes" : "No"}`));
+    console.log(chalk32.gray(`    \u2022 Scaffold: ${bundle.scaffold ? "Yes" : "No"}`));
+    if (bundle.scaffold) {
+      const requiredVars = getRequiredScaffoldVariables(bundle.scaffold);
+      if (requiredVars.length > 0) {
+        console.log(chalk32.gray(`    \u2022 Required variables: ${requiredVars.map((v) => v.name).join(", ")}`));
+      }
+    }
+    console.log();
+    console.log(chalk32.gray(`  Path: ${bundlePath}`));
+    console.log();
+    process.exit(0);
+  } catch (error) {
+    console.error(chalk32.red(`
+Error: ${error.message}
+`));
+    process.exit(1);
+  }
+});
+var removeCommand = new Command31("remove").alias("rm").description("Remove an installed bundle").argument("<name>", "Bundle name").option("-f, --force", "Skip confirmation").action(async (name, options) => {
+  try {
+    if (!options.force) {
+      const confirm = await confirmFn(`Remove bundle '${name}'?`);
+      if (!confirm) {
+        console.log(chalk32.gray("\n  Cancelled\n"));
+        process.exit(0);
+      }
+    }
+    const spinner = ora19(`Removing bundle ${name}...`).start();
+    const result = await removeBundle(name);
+    if (!result.success) {
+      spinner.fail(chalk32.red(result.error || "Remove failed"));
+      process.exit(1);
+    }
+    spinner.succeed(chalk32.green(`Removed ${name}`));
+    process.exit(0);
+  } catch (error) {
+    console.error(chalk32.red(`
+Error: ${error.message}
+`));
+    process.exit(1);
+  }
+});
+var updateCommand2 = new Command31("update").description("Update a bundle from its source").argument("<name>", "Bundle name").action(async (name) => {
+  const spinner = ora19(`Updating bundle ${name}...`).start();
+  try {
+    const result = await updateBundle(name);
+    if (!result.success) {
+      spinner.fail(chalk32.red(result.error || "Update failed"));
+      process.exit(1);
+    }
+    spinner.succeed(chalk32.green(`Updated ${result.bundle.manifest.name} to v${result.bundle.manifest.version}`));
+    process.exit(0);
+  } catch (error) {
+    spinner.fail(chalk32.red("Update failed"));
+    console.error(chalk32.red(`
+Error: ${error.message}
+`));
+    process.exit(1);
+  }
+});
+var deactivateCommand = new Command31("deactivate").description("Deactivate bundle from current project").argument("<name>", "Bundle name").action(async (name) => {
+  const spinner = ora19(`Deactivating bundle ${name}...`).start();
+  try {
+    const result = await deactivateBundle(name, process.cwd());
+    if (!result.success) {
+      spinner.fail(chalk32.red(result.error || "Deactivation failed"));
+      process.exit(1);
+    }
+    spinner.succeed(chalk32.green(`Deactivated ${name}`));
+    process.exit(0);
+  } catch (error) {
+    spinner.fail(chalk32.red("Deactivation failed"));
+    console.error(chalk32.red(`
+Error: ${error.message}
+`));
+    process.exit(1);
+  }
+});
+var bundleCommand = new Command31("bundle").description("Manage VibeTasks bundles (Studio + Scaffold + Blueprints)").addCommand(installCommand).addCommand(useCommand).addCommand(listCommand2).addCommand(infoCommand).addCommand(removeCommand).addCommand(updateCommand2).addCommand(deactivateCommand);
+
+// src/commands/ready.ts
+import { Command as Command32 } from "commander";
+import chalk33 from "chalk";
+import Table5 from "cli-table3";
+import { AuthManager as AuthManager29, TaskOperations as TaskOperations25 } from "@vibetasks/core";
+var readyCommand = new Command32("ready").description("Show tasks ready to work on (no blockers, not deferred)").option("-l, --limit <number>", "Maximum number of tasks to show", "20").option("--status <status>", "Filter by status: todo, vibing (default: vibing)", "vibing").option("--short-ids", "Show short numeric IDs for easy reference").option("--json", "Output as JSON").action(async (options) => {
+  try {
+    const authManager = new AuthManager29();
+    const taskOps = await TaskOperations25.fromAuthManager(authManager);
+    const tasks = await taskOps.getReadyTasks({
+      status: options.status,
+      limit: parseInt(options.limit, 10)
+    });
+    if (options.json) {
+      console.log(JSON.stringify(tasks, null, 2));
+      process.exit(0);
+    }
+    if (tasks.length === 0) {
+      console.log(chalk33.green("\n\u2728 No ready tasks - all caught up!\n"));
+      console.log(chalk33.gray("You might have:"));
+      console.log(chalk33.gray("  - Tasks blocked by dependencies"));
+      console.log(chalk33.gray("  - Tasks deferred for later (defer_until)"));
+      console.log(chalk33.gray("  - No open tasks at all\n"));
+      console.log(chalk33.gray("Run: vibetasks list --status todo  to see all pending tasks"));
+      console.log(chalk33.gray("Run: vibetasks blocked  to see what's blocking you\n"));
+      process.exit(0);
+    }
+    console.log(chalk33.green(`
+\u2705 ${tasks.length} task(s) ready to work on:
+`));
+    const shortIdManager = new ShortIdManager();
+    if (options.shortIds) {
+      await shortIdManager.saveMappings(tasks.map((t) => ({
+        id: t.id,
+        short_id: t.short_id
+      })));
+    }
+    const table = new Table5({
+      head: options.shortIds ? [chalk33.cyan("#"), chalk33.cyan("Pri"), chalk33.cyan("Title"), chalk33.cyan("Due")] : [chalk33.cyan("ID"), chalk33.cyan("Pri"), chalk33.cyan("Title"), chalk33.cyan("Due")],
+      colWidths: options.shortIds ? [8, 8, 45, 12] : [12, 8, 45, 12],
+      wordWrap: true
+    });
+    const priorityColors = {
+      high: chalk33.red,
+      medium: chalk33.yellow,
+      low: chalk33.blue,
+      none: chalk33.gray
+    };
+    const priorityEmojis = {
+      high: "\u{1F534}",
+      medium: "\u{1F7E1}",
+      low: "\u{1F535}",
+      none: "\u26AA"
+    };
+    tasks.forEach((task, index) => {
+      const priorityColor = priorityColors[task.priority || "none"];
+      const priorityEmoji = priorityEmojis[task.priority || "none"];
+      const shortId = chalk33.yellow.bold(task.short_id || `${index + 1}`);
+      const id = task.id.substring(0, 8);
+      const priority = priorityColor(`${priorityEmoji}`);
+      const title = task.title.length > 42 ? task.title.substring(0, 39) + "..." : task.title;
+      const dueDate = task.due_date ? task.due_date.split("T")[0] : chalk33.gray("-");
+      if (options.shortIds) {
+        table.push([shortId, priority, title, dueDate]);
+      } else {
+        table.push([id, priority, title, dueDate]);
+      }
+    });
+    console.log(table.toString());
+    if (options.shortIds) {
+      console.log(chalk33.gray(`
+Use: vibetasks vibing <short-id> to start working`));
+    } else {
+      console.log(chalk33.gray(`
+Use: vibetasks vibing <id> to start working`));
+    }
+    console.log();
+    process.exit(0);
+  } catch (error) {
+    if (error.message.includes("Not authenticated")) {
+      console.error(chalk33.yellow("\n\u26A0\uFE0F  You need to login first"));
+      console.error(chalk33.gray("Run: vibetasks login\n"));
+    } else {
+      console.error(chalk33.red(`
+Error: ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/stale.ts
+import { Command as Command33 } from "commander";
+import chalk34 from "chalk";
+import Table6 from "cli-table3";
+import { AuthManager as AuthManager30, TaskOperations as TaskOperations26 } from "@vibetasks/core";
+var staleCommand = new Command33("stale").description("Show stale tasks (not updated recently)").option("-d, --days <number>", "Tasks not updated in this many days", "7").option("-l, --limit <number>", "Maximum number of tasks to show", "50").option("--status <status>", "Filter by status: todo, vibing").option("--short-ids", "Show short numeric IDs for easy reference").option("--json", "Output as JSON").option("--fix", "Interactively close or update stale tasks").action(async (options) => {
+  try {
+    const authManager = new AuthManager30();
+    const taskOps = await TaskOperations26.fromAuthManager(authManager);
+    const days = parseInt(options.days, 10);
+    const tasks = await taskOps.getStaleTasks({
+      days,
+      status: options.status,
+      limit: parseInt(options.limit, 10)
+    });
+    if (options.json) {
+      console.log(JSON.stringify(tasks, null, 2));
+      process.exit(0);
+    }
+    if (tasks.length === 0) {
+      console.log(chalk34.green(`
+\u2728 No stale tasks found (all updated within ${days} days)
+`));
+      process.exit(0);
+    }
+    console.log(chalk34.yellow(`
+\u23F0 ${tasks.length} stale task(s) (not updated in ${days}+ days):
+`));
+    const shortIdManager = new ShortIdManager();
+    if (options.shortIds) {
+      await shortIdManager.saveMappings(tasks.map((t) => ({
+        id: t.id,
+        short_id: t.short_id
+      })));
+    }
+    const table = new Table6({
+      head: [
+        options.shortIds ? chalk34.cyan("#") : chalk34.cyan("ID"),
+        chalk34.cyan("Status"),
+        chalk34.cyan("Title"),
+        chalk34.cyan("Days Stale"),
+        chalk34.cyan("Session")
+      ],
+      colWidths: options.shortIds ? [8, 10, 35, 12, 12] : [12, 10, 35, 12, 12],
+      wordWrap: true
+    });
+    const statusColors = {
+      todo: chalk34.gray,
+      vibing: chalk34.magenta,
+      paused: chalk34.yellow
+    };
+    tasks.forEach((task, index) => {
+      const statusColor = statusColors[task.status] || chalk34.white;
+      const daysStale = task.days_stale || Math.floor((Date.now() - new Date(task.updated_at).getTime()) / (1e3 * 60 * 60 * 24));
+      const shortId = chalk34.yellow.bold(task.short_id || `${index + 1}`);
+      const id = task.id.substring(0, 8);
+      const status = statusColor(task.status);
+      const title = task.title.length > 32 ? task.title.substring(0, 29) + "..." : task.title;
+      const daysStaleStr = daysStale > 30 ? chalk34.red(`${daysStale}d`) : chalk34.yellow(`${daysStale}d`);
+      const sessionId = task.session_id ? task.session_id.substring(0, 8) : chalk34.gray("none");
+      if (options.shortIds) {
+        table.push([shortId, status, title, daysStaleStr, sessionId]);
+      } else {
+        table.push([id, status, title, daysStaleStr, sessionId]);
+      }
+    });
+    console.log(table.toString());
+    console.log(chalk34.gray("\nThese tasks may be:"));
+    console.log(chalk34.gray("  - Abandoned work from a previous session"));
+    console.log(chalk34.gray("  - Completed but not marked done"));
+    console.log(chalk34.gray("  - Blocked and forgotten"));
+    console.log();
+    if (!options.fix) {
+      console.log(chalk34.gray("Run: vibetasks stale --fix  to interactively clean up"));
+      console.log(chalk34.gray("Run: vibetasks done <id>  to mark a task complete"));
+      console.log(chalk34.gray("Run: vibetasks archive <id>  to archive a task"));
+    } else {
+      console.log(chalk34.cyan("\n--- Interactive Cleanup Mode ---\n"));
+      const readline2 = await import("readline");
+      const rl = readline2.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      for (const task of tasks) {
+        const answer = await new Promise((resolve) => {
+          rl.question(
+            chalk34.white(`
+"${task.title}" (${task.status}, ${task.days_stale || "?"}d stale)
+`) + chalk34.gray("  [d]one, [a]rchive, [s]kip, [q]uit: "),
+            resolve
+          );
+        });
+        const choice = answer.toLowerCase().trim();
+        if (choice === "q" || choice === "quit") {
+          console.log(chalk34.gray("\nExiting cleanup mode."));
+          break;
+        } else if (choice === "d" || choice === "done") {
+          await taskOps.completeTask(task.id);
+          console.log(chalk34.green(`  \u2713 Marked done: ${task.title}`));
+        } else if (choice === "a" || choice === "archive") {
+          await taskOps.archiveTask(task.id);
+          console.log(chalk34.blue(`  \u{1F4E6} Archived: ${task.title}`));
+        } else {
+          console.log(chalk34.gray("  Skipped"));
+        }
+      }
+      rl.close();
+      console.log(chalk34.green("\n\u2705 Cleanup complete!\n"));
+    }
+    console.log();
+    process.exit(0);
+  } catch (error) {
+    if (error.message.includes("Not authenticated")) {
+      console.error(chalk34.yellow("\n\u26A0\uFE0F  You need to login first"));
+      console.error(chalk34.gray("Run: vibetasks login\n"));
+    } else {
+      console.error(chalk34.red(`
+Error: ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/orphans.ts
+import { Command as Command34 } from "commander";
+import chalk35 from "chalk";
+import Table7 from "cli-table3";
+import { AuthManager as AuthManager31, TaskOperations as TaskOperations27 } from "@vibetasks/core";
+var orphansCommand = new Command34("orphans").description("Find orphaned tasks (incomplete tasks from old AI sessions)").option("-l, --limit <number>", "Maximum number of tasks to show", "50").option("--short-ids", "Show short numeric IDs for easy reference").option("--json", "Output as JSON").option("--fix", "Interactively close or reassign orphaned tasks").option("--adopt", "Adopt orphaned tasks into current session").action(async (options) => {
+  try {
+    const authManager = new AuthManager31();
+    const taskOps = await TaskOperations27.fromAuthManager(authManager);
+    const sessionManager2 = getSessionManager();
+    const currentSession = await sessionManager2.getCurrentSession();
+    const currentSessionId = currentSession?.id;
+    const tasks = await taskOps.getOrphanedTasks({
+      currentSessionId,
+      limit: parseInt(options.limit, 10)
+    });
+    if (options.json) {
+      console.log(JSON.stringify(tasks, null, 2));
+      process.exit(0);
+    }
+    if (tasks.length === 0) {
+      console.log(chalk35.green("\n\u2728 No orphaned tasks found!\n"));
+      console.log(chalk35.gray("All in-progress tasks are from the current session."));
+      process.exit(0);
+    }
+    console.log(chalk35.yellow(`
+\u{1F50D} Found ${tasks.length} orphaned task(s) from previous sessions:
+`));
+    const shortIdManager = new ShortIdManager();
+    if (options.shortIds) {
+      await shortIdManager.saveMappings(tasks.map((t) => ({
+        id: t.id,
+        short_id: t.short_id
+      })));
+    }
+    const table = new Table7({
+      head: [
+        options.shortIds ? chalk35.cyan("#") : chalk35.cyan("ID"),
+        chalk35.cyan("Status"),
+        chalk35.cyan("Title"),
+        chalk35.cyan("Progress"),
+        chalk35.cyan("Session")
+      ],
+      colWidths: options.shortIds ? [8, 10, 35, 12, 12] : [12, 10, 35, 12, 12],
+      wordWrap: true
+    });
+    const statusColors = {
+      todo: chalk35.gray,
+      vibing: chalk35.magenta,
+      paused: chalk35.yellow
+    };
+    tasks.forEach((task, index) => {
+      const statusColor = statusColors[task.status] || chalk35.white;
+      const shortId = chalk35.yellow.bold(task.short_id || `${index + 1}`);
+      const id = task.id.substring(0, 8);
+      const status = statusColor(task.status);
+      const title = task.title.length > 32 ? task.title.substring(0, 29) + "..." : task.title;
+      const subtasksTotal = task.subtasks_total || 0;
+      const subtasksDone = task.subtasks_done || 0;
+      const progress = subtasksTotal > 0 ? subtasksDone === subtasksTotal ? chalk35.green(`${subtasksDone}/${subtasksTotal}`) : chalk35.yellow(`${subtasksDone}/${subtasksTotal}`) : chalk35.gray("0/0");
+      const sessionId = task.session_id ? task.session_id === currentSessionId ? chalk35.green("current") : task.session_id.substring(0, 8) : chalk35.gray("none");
+      if (options.shortIds) {
+        table.push([shortId, status, title, progress, sessionId]);
+      } else {
+        table.push([id, status, title, progress, sessionId]);
+      }
+    });
+    console.log(table.toString());
+    const tasksWithContext = tasks.filter((t) => t.context_notes);
+    if (tasksWithContext.length > 0) {
+      console.log(chalk35.cyan("\n\u{1F4DD} Tasks with handoff context:\n"));
+      tasksWithContext.slice(0, 3).forEach((task) => {
+        console.log(chalk35.white(`  ${task.title}:`));
+        const preview = task.context_notes.length > 100 ? task.context_notes.substring(0, 100) + "..." : task.context_notes;
+        console.log(chalk35.gray(`    ${preview}
+`));
+      });
+    }
+    console.log(chalk35.gray("\nThese tasks were started by a previous AI session but not completed."));
+    console.log(chalk35.gray("They may represent:"));
+    console.log(chalk35.gray("  - Work interrupted by session timeout/crash"));
+    console.log(chalk35.gray("  - Tasks the AI forgot to complete"));
+    console.log(chalk35.gray("  - Partially done work that needs finishing"));
+    console.log();
+    if (options.adopt && currentSessionId) {
+      console.log(chalk35.cyan("\u{1F504} Adopting orphaned tasks into current session...\n"));
+      for (const task of tasks) {
+        await taskOps.updateTask(task.id, { session_id: currentSessionId });
+        console.log(chalk35.green(`  \u2713 Adopted: ${task.title}`));
+      }
+      console.log(chalk35.green(`
+\u2705 Adopted ${tasks.length} task(s) into current session.
+`));
+    } else if (options.fix) {
+      console.log(chalk35.cyan("\n--- Interactive Cleanup Mode ---\n"));
+      const readline2 = await import("readline");
+      const rl = readline2.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      for (const task of tasks) {
+        const progressStr = `${task.subtasks_done || 0}/${task.subtasks_total || 0}`;
+        const answer = await new Promise((resolve) => {
+          rl.question(
+            chalk35.white(`
+"${task.title}" (${task.status}, ${progressStr} subtasks)
+`) + (task.context_notes ? chalk35.gray(`  Context: ${task.context_notes.substring(0, 80)}...
+`) : "") + chalk35.gray("  [a]dopt to current session, [d]one, [r]emove, [s]kip, [q]uit: "),
+            resolve
+          );
+        });
+        const choice = answer.toLowerCase().trim();
+        if (choice === "q" || choice === "quit") {
+          console.log(chalk35.gray("\nExiting cleanup mode."));
+          break;
+        } else if (choice === "a" || choice === "adopt") {
+          if (currentSessionId) {
+            await taskOps.updateTask(task.id, { session_id: currentSessionId });
+            console.log(chalk35.green(`  \u2713 Adopted: ${task.title}`));
+          } else {
+            console.log(chalk35.yellow("  No current session. Start one with: vibetasks session start"));
+          }
+        } else if (choice === "d" || choice === "done") {
+          await taskOps.completeTask(task.id);
+          console.log(chalk35.green(`  \u2713 Marked done: ${task.title}`));
+        } else if (choice === "r" || choice === "remove") {
+          await taskOps.archiveTask(task.id);
+          console.log(chalk35.blue(`  \u{1F4E6} Archived: ${task.title}`));
+        } else {
+          console.log(chalk35.gray("  Skipped"));
+        }
+      }
+      rl.close();
+      console.log(chalk35.green("\n\u2705 Cleanup complete!\n"));
+    } else {
+      console.log(chalk35.gray("Run: vibetasks orphans --fix  to interactively clean up"));
+      console.log(chalk35.gray("Run: vibetasks orphans --adopt  to adopt all into current session"));
+      console.log(chalk35.gray("Run: vibetasks show <id>  to see full task details"));
+      console.log();
+    }
+    process.exit(0);
+  } catch (error) {
+    if (error.message.includes("Not authenticated")) {
+      console.error(chalk35.yellow("\n\u26A0\uFE0F  You need to login first"));
+      console.error(chalk35.gray("Run: vibetasks login\n"));
+    } else {
+      console.error(chalk35.red(`
+Error: ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/blocked.ts
+import { Command as Command35 } from "commander";
+import chalk36 from "chalk";
+import Table8 from "cli-table3";
+import { AuthManager as AuthManager32, TaskOperations as TaskOperations28 } from "@vibetasks/core";
+var blockedCommand = new Command35("blocked").description("Show tasks blocked by dependencies").option("-l, --limit <number>", "Maximum number of tasks to show", "50").option("--short-ids", "Show short numeric IDs for easy reference").option("--json", "Output as JSON").action(async (options) => {
+  try {
+    const authManager = new AuthManager32();
+    const taskOps = await TaskOperations28.fromAuthManager(authManager);
+    const tasks = await taskOps.getBlockedTasks({
+      limit: parseInt(options.limit, 10)
+    });
+    if (options.json) {
+      console.log(JSON.stringify(tasks, null, 2));
+      process.exit(0);
+    }
+    if (tasks.length === 0) {
+      console.log(chalk36.green("\n\u2728 No blocked tasks - nothing is waiting!\n"));
+      process.exit(0);
+    }
+    console.log(chalk36.yellow(`
+\u{1F6A7} ${tasks.length} blocked task(s):
+`));
+    const shortIdManager = new ShortIdManager();
+    if (options.shortIds) {
+      await shortIdManager.saveMappings(tasks.map((t) => ({
+        id: t.id,
+        short_id: t.short_id
+      })));
+    }
+    const table = new Table8({
+      head: [
+        options.shortIds ? chalk36.cyan("#") : chalk36.cyan("ID"),
+        chalk36.cyan("Pri"),
+        chalk36.cyan("Title"),
+        chalk36.cyan("Blocked By")
+      ],
+      colWidths: options.shortIds ? [8, 6, 35, 30] : [12, 6, 35, 30],
+      wordWrap: true
+    });
+    const priorityColors = {
+      high: chalk36.red,
+      medium: chalk36.yellow,
+      low: chalk36.blue,
+      none: chalk36.gray
+    };
+    tasks.forEach((task, index) => {
+      const priorityKey = task.priority || "none";
+      const priorityColor = priorityColors[priorityKey];
+      const shortId = chalk36.yellow.bold(task.short_id || `${index + 1}`);
+      const id = task.id.substring(0, 8);
+      const priority = priorityColor(task.priority?.[0]?.toUpperCase() || "-");
+      const title = task.title.length > 32 ? task.title.substring(0, 29) + "..." : task.title;
+      const blockerCount = task.blocked_by_count || 0;
+      const blockerTitles = (task.blocker_titles || []).slice(0, 2);
+      let blockedBy = "";
+      if (blockerCount === 0) {
+        blockedBy = chalk36.gray("deferred");
+      } else if (blockerTitles.length > 0) {
+        blockedBy = blockerTitles.map(
+          (t) => chalk36.red(t.length > 12 ? t.substring(0, 9) + "..." : t)
+        ).join(", ");
+        if (blockerCount > blockerTitles.length) {
+          blockedBy += chalk36.gray(` +${blockerCount - blockerTitles.length} more`);
+        }
+      } else {
+        blockedBy = chalk36.red(`${blockerCount} task(s)`);
+      }
+      if (options.shortIds) {
+        table.push([shortId, priority, title, blockedBy]);
+      } else {
+        table.push([id, priority, title, blockedBy]);
+      }
+    });
+    console.log(table.toString());
+    console.log(chalk36.gray("\nTo unblock tasks:"));
+    console.log(chalk36.gray("  1. Complete the blocking tasks first"));
+    console.log(chalk36.gray("  2. Or remove the dependency with: vibetasks dep remove <task-id> <blocker-id>"));
+    console.log();
+    console.log(chalk36.gray("Run: vibetasks ready  to see tasks you can work on now"));
+    console.log();
+    process.exit(0);
+  } catch (error) {
+    if (error.message.includes("Not authenticated")) {
+      console.error(chalk36.yellow("\n\u26A0\uFE0F  You need to login first"));
+      console.error(chalk36.gray("Run: vibetasks login\n"));
+    } else {
+      console.error(chalk36.red(`
+Error: ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/compact.ts
+import { Command as Command36 } from "commander";
+import chalk37 from "chalk";
+import ora20 from "ora";
+import { AuthManager as AuthManager33, TaskOperations as TaskOperations29, createCompactionService } from "@vibetasks/core";
+var compactCommand = new Command36("compact").description("Compact old completed tasks using AI summarization").option("-d, --days <number>", "Minimum days since completion (default: 7)", "7").option("-l, --limit <number>", "Maximum tasks to compact in one run", "10").option("--dry-run", "Preview what would be compacted without making changes").option("--stats", "Show compaction statistics only").option("--json", "Output as JSON").action(async (options) => {
+  try {
+    const authManager = new AuthManager33();
+    const taskOps = await TaskOperations29.fromAuthManager(authManager);
+    if (options.stats) {
+      const stats = await taskOps.getCompactionStats();
+      if (options.json) {
+        console.log(JSON.stringify(stats, null, 2));
+        process.exit(0);
+      }
+      console.log(chalk37.cyan("\n\u{1F4CA} Compaction Statistics\n"));
+      console.log(`  Total completed tasks: ${chalk37.white(stats.totalCompleted)}`);
+      console.log(`  Already compacted:     ${chalk37.green(stats.compacted)}`);
+      console.log(`  Eligible for compact:  ${chalk37.yellow(stats.eligible)}`);
+      console.log();
+      if (stats.eligible > 0) {
+        console.log(chalk37.gray(`Run: vibetasks compact  to summarize ${stats.eligible} old task(s)`));
+      } else {
+        console.log(chalk37.green("\u2728 All eligible tasks are already compacted!"));
+      }
+      console.log();
+      process.exit(0);
+    }
+    const minDays = parseInt(options.days, 10);
+    const limit = parseInt(options.limit, 10);
+    const tasks = await taskOps.getCompactableTasks({
+      minDaysOld: minDays,
+      limit
+    });
+    if (tasks.length === 0) {
+      console.log(chalk37.green("\n\u2728 No tasks eligible for compaction\n"));
+      console.log(chalk37.gray(`Tasks must be completed more than ${minDays} days ago to be compacted.`));
+      console.log(chalk37.gray("Run: vibetasks compact --stats  to see compaction statistics"));
+      console.log();
+      process.exit(0);
+    }
+    if (options.dryRun) {
+      console.log(chalk37.yellow(`
+\u{1F50D} Dry run: ${tasks.length} task(s) would be compacted:
+`));
+      tasks.forEach((task, i) => {
+        const completedDate = task.completed_at ? new Date(task.completed_at).toLocaleDateString() : "unknown";
+        console.log(`  ${i + 1}. ${task.title}`);
+        console.log(chalk37.gray(`     Completed: ${completedDate}`));
+      });
+      console.log();
+      console.log(chalk37.gray("Remove --dry-run to actually compact these tasks"));
+      console.log();
+      process.exit(0);
+    }
+    if (!process.env.ANTHROPIC_API_KEY) {
+      console.error(chalk37.red("\n\u274C ANTHROPIC_API_KEY environment variable required for compaction"));
+      console.error(chalk37.gray("Set it with: export ANTHROPIC_API_KEY=your-key"));
+      process.exit(1);
+    }
+    console.log(chalk37.cyan(`
+\u{1F5DC}\uFE0F  Compacting ${tasks.length} old task(s)...
+`));
+    const compactionService = createCompactionService();
+    const results = [];
+    let successCount = 0;
+    let failCount = 0;
+    let totalSaved = 0;
+    for (const task of tasks) {
+      const spinner = ora20(`Compacting: ${task.title.substring(0, 40)}...`).start();
+      try {
+        const result = await compactionService.compactTask(task);
+        if (result.success) {
+          await taskOps.applyCompaction(task.id, result.summary);
+          const saved = result.originalSize - result.compactedSize;
+          totalSaved += saved;
+          successCount++;
+          spinner.succeed(
+            `${task.title.substring(0, 30)}... ` + chalk37.green(`(${result.originalSize} \u2192 ${result.compactedSize} chars, saved ${saved})`)
+          );
+          results.push({
+            taskId: task.id,
+            title: task.title,
+            ...result
+          });
+        } else {
+          failCount++;
+          spinner.fail(`${task.title.substring(0, 30)}... ${chalk37.red(result.error)}`);
+          results.push({
+            taskId: task.id,
+            title: task.title,
+            ...result
+          });
+        }
+      } catch (error) {
+        failCount++;
+        spinner.fail(`${task.title.substring(0, 30)}... ${chalk37.red(error.message)}`);
+        results.push({
+          taskId: task.id,
+          title: task.title,
+          success: false,
+          error: error.message
+        });
+      }
+    }
+    if (options.json) {
+      console.log(JSON.stringify(results, null, 2));
+      process.exit(0);
+    }
+    console.log();
+    console.log(chalk37.cyan("\u{1F4CA} Summary:"));
+    console.log(`  Compacted: ${chalk37.green(successCount)} task(s)`);
+    if (failCount > 0) {
+      console.log(`  Failed:    ${chalk37.red(failCount)} task(s)`);
+    }
+    console.log(`  Saved:     ${chalk37.yellow(totalSaved)} characters`);
+    console.log();
+    if (successCount > 0) {
+      console.log(chalk37.green("\u2705 Context compaction complete!"));
+      console.log(chalk37.gray("Compacted summaries are stored in context_summary field."));
+    }
+    console.log();
+    process.exit(failCount > 0 ? 1 : 0);
+  } catch (error) {
+    if (error.message.includes("Not authenticated")) {
+      console.error(chalk37.yellow("\n\u26A0\uFE0F  You need to login first"));
+      console.error(chalk37.gray("Run: vibetasks login\n"));
+    } else {
+      console.error(chalk37.red(`
+Error: ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+});
+
 // bin/vibetasks.ts
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../../package.json");
-var program = new Command21();
+var program = new Command37();
 program.name("vibetasks").description("VibeTasks CLI - Fast task management for vibers").version(pkg.version);
 program.addCommand(setupCommand);
 program.addCommand(loginCommand);
@@ -3860,4 +6871,20 @@ 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.addCommand(researchCommand);
+program.addCommand(bundleCommand);
+program.addCommand(readyCommand);
+program.addCommand(staleCommand);
+program.addCommand(orphansCommand);
+program.addCommand(blockedCommand);
+program.addCommand(compactCommand);
 program.parse();