@vibetasks/cli 0.6.11 → 0.6.13

package/dist/bin/vibetasks.js

@@ -11,7 +11,7 @@ import {
 } from "../chunk-2KRLRG4G.js";
 
 // bin/vibetasks.ts
-import { Command as Command30 } from "commander";
+import { Command as Command37 } from "commander";
 import { createRequire } from "module";
 
 // src/commands/login.ts
@@ -415,7 +415,7 @@ 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",
@@ -555,11 +555,12 @@ var SessionManager = class {
   }
   /**
    * 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}`;
   }
   /**
@@ -725,7 +726,7 @@ var SessionManager = class {
    * Includes: vibing tasks with context, git status, files changed, next steps
    */
   async generateHandoff() {
-    const { execSync: execSync2 } = await import("child_process");
+    const { execSync: execSync3 } = await import("child_process");
     const lines = [];
     lines.push("# AI Handoff");
     lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}`);
@@ -739,7 +740,7 @@ var SessionManager = class {
       lines.push("");
     }
     try {
-      const gitStatus = execSync2("git status --porcelain", { encoding: "utf-8", timeout: 5e3 }).trim();
+      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");
@@ -752,7 +753,7 @@ var SessionManager = class {
     } catch {
     }
     try {
-      const recentCommits = execSync2("git log --oneline -3", { encoding: "utf-8", timeout: 5e3 }).trim();
+      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}`));
@@ -787,7 +788,8 @@ import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
 var ShortIdManager = class {
   storePath;
-  maxIds = 99;
+  maxIds = 9999;
+  // Support up to 9999 short IDs (database assigns them)
   constructor() {
     this.storePath = join2(homedir2(), ".vibetasks", "short-ids.json");
   }
@@ -837,25 +839,54 @@ var ShortIdManager = class {
     }
   }
   /**
-   * Resolve an ID that could be either short (1-99) or full UUID
+   * Resolve a partial UUID (8 characters) to full UUID by searching database
    */
-  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;
-      }
+  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(
-        `Short ID #${shortId} not found. Run 'vibetasks list --short-ids' first to generate mappings.`
+        `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").option("-a, --acceptance <criteria...>", 'Acceptance criteria - "DONE WHEN" conditions (use quotes for multi-word)').option("-f, --files <files...>", "Relevant files for this task").option("--non-goals <goals...>", "Explicit non-goals / out of scope items").action(async (title, options) => {
+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 AuthManager3();
@@ -893,11 +924,34 @@ var addCommand = new Command2("add").description("Add a new task").argument("<ti
         throw new Error(`Invalid energy level. Must be one of: ${validEnergy.join(", ")}`);
       }
     }
-    const subtasksJson = options.subtasks?.map((subtaskTitle) => ({
-      id: randomUUID2(),
-      title: subtaskTitle,
-      done: false
-    })) || [];
+    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(),
       text,
@@ -917,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,
@@ -927,6 +982,8 @@ 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,
@@ -971,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) {
@@ -998,6 +1060,21 @@ 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) {
@@ -1059,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);
@@ -1157,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("-");
@@ -1214,10 +1297,10 @@ var doneCommand = new Command4("done").description("Mark a task as complete").ar
     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(`
@@ -1225,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,
@@ -1248,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}"`,
@@ -1270,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);
   }
@@ -1284,16 +1379,20 @@ import { Command as Command5 } from "commander";
 import chalk6 from "chalk";
 import ora4 from "ora";
 import inquirer from "inquirer";
-import { AuthManager as AuthManager6, TaskOperations as TaskOperations4 } from "@vibetasks/core";
-var vibingCommand = new Command5("vibing").alias("start").alias("v").description("Start working on a task (move to vibing status)").argument("[task-id]", "Task ID or short # (1-99) to start vibing on").option("-p, --pick", "Pick from todo tasks interactively").action(async (taskIdInput, options) => {
+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 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);
@@ -1301,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'));
@@ -1316,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 || [];
@@ -1335,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,
@@ -1344,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"));
@@ -1437,19 +1608,8 @@ var updateCommand = new Command7("update").description("Update a task").argument
   try {
     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;
@@ -1477,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}
@@ -1507,23 +1667,10 @@ var deleteCommand = new Command8("delete").description("Delete a task").argument
   try {
     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([
         {
@@ -1539,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}
@@ -1623,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 {
@@ -1641,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
@@ -1697,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: [
@@ -1716,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");
@@ -1763,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")) {
@@ -1775,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);
@@ -1863,7 +2010,7 @@ 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";
@@ -1905,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 {
@@ -2125,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 {
@@ -2374,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 = {};
@@ -2705,7 +2852,7 @@ import chalk15 from "chalk";
 import ora11 from "ora";
 import inquirer6 from "inquirer";
 import { AuthManager as AuthManager14, TaskOperations as TaskOperations10 } from "@vibetasks/core";
-var archiveCommand = new Command14("archive").description("Archive a task or manage archived tasks").argument("[task-id]", "Task ID to archive (full or first 8 characters)").option("-l, --list", "List all archived tasks").option("-u, --unarchive <id>", "Unarchive a task by ID").option("--pick", "Pick from completed tasks to archive").action(async (taskId, options) => {
+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 AuthManager14();
@@ -2754,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"));
@@ -2769,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) {
@@ -2787,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);
       }
@@ -2820,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 { 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) => {
@@ -3026,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: {
@@ -3484,6 +3631,31 @@ var sessionCommand = new Command17("session").description("Manage AI sessions fo
       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();
@@ -3544,20 +3716,8 @@ subtaskCommand.command("list").description("List subtasks for a task").argument(
     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();
@@ -3592,20 +3752,8 @@ subtaskCommand.command("done").description("Mark subtasks as complete").argument
     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"));
@@ -3639,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();
@@ -3650,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);
@@ -3668,20 +3816,8 @@ subtaskCommand.command("undo").description("Mark subtasks as incomplete").argume
     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"));
@@ -3715,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();
@@ -4072,14 +4208,288 @@ 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";
-var handoffCommand = new Command21("handoff").description("Generate comprehensive handoff for the next AI (vibing tasks, context notes, git status)").argument("[session-id]", "Session ID (shows that session only)").option("--full", "Include full action history from session").action(async (sessionId, options) => {
+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) {
+  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();
@@ -4140,8 +4550,8 @@ var handoffCommand = new Command21("handoff").description("Generate comprehensiv
     console.log();
   }
   try {
-    const { execSync: execSync2 } = await import("child_process");
-    const gitStatus = execSync2("git status --porcelain", { encoding: "utf-8", timeout: 5e3 }).trim();
+    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)`));
@@ -4151,7 +4561,7 @@ var handoffCommand = new Command21("handoff").description("Generate comprehensiv
       }
       console.log();
     }
-    const commits = execSync2("git log --oneline -3", { encoding: "utf-8", timeout: 5e3 }).trim();
+    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}`)));
@@ -4180,7 +4590,7 @@ import { readFile as readFile3 } from "fs/promises";
 import { existsSync } from "fs";
 import { AuthManager as AuthManager21, TaskOperations as TaskOperations17 } from "@vibetasks/core";
 import { detectProject as detectProject6 } from "@vibetasks/shared/utils/project-detector";
-import { randomUUID as randomUUID3 } from "crypto";
+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 {
@@ -4200,7 +4610,7 @@ var parsePrdCommand = new Command22("parse-prd").description("Parse a PRD/requir
     }
     const finalTitle = options.title || parsed.title || "Implement PRD";
     const subtasksJson = parsed.tasks.map((task2, i) => ({
-      id: randomUUID3(),
+      id: randomUUID4(),
       title: task2,
       done: false
     }));
@@ -4453,21 +4863,21 @@ function parsePrdContent(content, verbose = false) {
 import { Command as Command23 } from "commander";
 import chalk24 from "chalk";
 import { AuthManager as AuthManager22, TaskOperations as TaskOperations18 } from "@vibetasks/core";
-import { execSync } from "child_process";
+import { 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 (taskId, options) => {
+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 (taskId) {
+    if (taskId2) {
       const allTasks = await taskOps.getTasks("all");
       task = allTasks.find(
-        (t) => t.id.startsWith(taskId) || t.short_id?.toString() === taskId
+        (t) => t.id.startsWith(taskId2) || t.short_id?.toString() === taskId2
       );
       if (!task) {
-        console.error(chalk24.red(`Task not found: ${taskId}`));
+        console.error(chalk24.red(`Task not found: ${taskId2}`));
         process.exit(1);
       }
     } else {
@@ -4591,9 +5001,9 @@ Error: ${error.message}
 function getGitContext() {
   const parts = [];
   try {
-    const branch = execSync("git branch --show-current", { encoding: "utf-8" }).trim();
+    const branch = execSync2("git branch --show-current", { encoding: "utf-8" }).trim();
     parts.push(`Branch: ${branch}`);
-    const status = execSync("git status --porcelain", { encoding: "utf-8" }).trim();
+    const status = execSync2("git status --porcelain", { encoding: "utf-8" }).trim();
     if (status) {
       const lines = status.split("\n").slice(0, 20);
       parts.push(`
@@ -4603,7 +5013,7 @@ ${lines.join("\n")}`);
         parts.push(`... and ${status.split("\n").length - 20} more`);
       }
     }
-    const log = execSync("git log --oneline -3", { encoding: "utf-8" }).trim();
+    const log = execSync2("git log --oneline -3", { encoding: "utf-8" }).trim();
     if (log) {
       parts.push(`
 Recent commits:
@@ -4619,7 +5029,7 @@ ${log}`);
 import { Command as Command24 } from "commander";
 import chalk25 from "chalk";
 import { AuthManager as AuthManager23, TaskOperations as TaskOperations19 } from "@vibetasks/core";
-var logCommand = new Command24("log").description("Show change history for a task (like git log)").argument("[task]", "Task ID or short number").option("-n, --limit <number>", "Maximum number of changes to show", "20").option("--oneline", "Compact one-line format").option("--since <date>", "Show changes after date (YYYY-MM-DD)").option("--until <date>", "Show changes before date (YYYY-MM-DD)").option("--type <types>", "Filter by change type (comma-separated)").option("--grep <query>", "Search change messages (ignores task arg)").option("--session <id>", "Show changes from specific session").action(async (taskArg, options) => {
+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);
@@ -4644,19 +5054,19 @@ Found ${changes2.length} change(s) matching "${options.grep}":
       console.error(chalk25.gray('Usage: vibetasks log <task-id> or vibetasks log --grep "query"'));
       process.exit(1);
     }
-    let taskId = taskArg;
+    let taskId2 = taskArg;
     if (/^\d+$/.test(taskArg)) {
       const shortIdManager = new ShortIdManager();
       const resolved = await shortIdManager.resolveId(taskArg);
       if (resolved) {
-        taskId = 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(taskId);
+    const task = await taskOps.getTask(taskId2);
     const queryOptions = {
       limit: parseInt(options.limit, 10)
     };
@@ -4669,7 +5079,32 @@ Found ${changes2.length} change(s) matching "${options.grep}":
     if (options.type) {
       queryOptions.changeTypes = options.type.split(",").map((t) => t.trim());
     }
-    const changes = await taskOps.getTaskChanges(taskId, queryOptions);
+    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}
@@ -4678,7 +5113,7 @@ No change history found for task: ${task.title}
     }
     console.log();
     console.log(chalk25.cyan.bold(`History for: ${task.title}`));
-    console.log(chalk25.gray(`Task ID: ${taskId}`));
+    console.log(chalk25.gray(`Task ID: ${taskId2}`));
     console.log(chalk25.gray(`Status: ${task.status} | Changes: ${changes.length}`));
     console.log();
     for (const change of changes) {
@@ -4718,15 +5153,41 @@ function printChange(change, oneline = false, taskTitle) {
     handoff: chalk25.magenta
   };
   const colorFn = typeColors[change.change_type] || chalk25.white;
-  const actorIcon = change.actor_type === "ai" ? "\u{1F916}" : change.actor_type === "human" ? "\u{1F464}" : "\u2699\uFE0F";
+  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 message = change.message || change.change_type;
+    const message2 = change.message || change.change_type;
     console.log(
-      `${chalk25.yellow(changeId)} ${chalk25.gray(dateStr)} ${colorFn(change.change_type.padEnd(16))} ${actorIcon} ${message}`
+      `${chalk25.yellow(changeId)} ${chalk25.gray(dateStr)} ${colorFn(change.change_type.padEnd(16))} ${actorIcon} ${message2}`
     );
   } else {
     console.log(chalk25.yellow(`change ${change.id}`));
-    console.log(`Actor:  ${actorIcon} ${change.actor_type}`);
+    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)}`));
@@ -4877,12 +5338,12 @@ Total: ${pausedTasks.length} paused task(s)
       console.log(chalk27.gray("  vibetasks pause --list        # List paused tasks\n"));
       process.exit(1);
     }
-    let taskId = taskArg;
+    let taskId2 = taskArg;
     if (/^\d+$/.test(taskArg)) {
       const shortIdManager = new ShortIdManager();
       const resolved = await shortIdManager.resolveId(taskArg);
       if (resolved) {
-        taskId = 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"));
@@ -4895,14 +5356,14 @@ Total: ${pausedTasks.length} paused task(s)
         console.error(chalk27.red(`Task not found: ${taskArg}`));
         process.exit(1);
       }
-      taskId = matchingTask.id;
+      taskId2 = matchingTask.id;
     }
-    const task = await taskOps.getTask(taskId);
+    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 " + taskId.slice(0, 8) + "\n"));
+      console.log(chalk27.gray("Resume with: vibetasks resume " + taskId2.slice(0, 8) + "\n"));
       process.exit(0);
     }
     if (task.status === "done" || task.status === "archived") {
@@ -4912,7 +5373,7 @@ Cannot pause a ${task.status} task.
       process.exit(1);
     }
     spinner.start("Pausing task...");
-    const pausedTask = await taskOps.pauseTask(taskId, options.message);
+    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));
@@ -4920,7 +5381,7 @@ Cannot pause a ${task.status} task.
       console.log(chalk27.gray(`   Reason: ${options.message}`));
     }
     console.log();
-    console.log(chalk27.gray(`Resume with: vibetasks resume ${taskId.slice(0, 8)}`));
+    console.log(chalk27.gray(`Resume with: vibetasks resume ${taskId2.slice(0, 8)}`));
     console.log(chalk27.gray(`View paused: vibetasks pause --list`));
     console.log();
     process.exit(0);
@@ -4956,10 +5417,10 @@ var resumeCommand = new Command27("resume").description("Resume a paused task (l
       console.log(chalk28.gray("Pause a task with: vibetasks pause <task-id>\n"));
       process.exit(0);
     }
-    let taskId;
+    let taskId2;
     if (!taskArg) {
       if (pausedTasks.length === 1) {
-        taskId = pausedTasks[0].id;
+        taskId2 = pausedTasks[0].id;
         console.log(chalk28.gray(`
 Auto-selecting the only paused task...
 `));
@@ -4973,15 +5434,15 @@ Auto-selecting the only paused task...
             value: t.id
           }))
         }]);
-        taskId = selectedTask;
+        taskId2 = selectedTask;
       }
     } else {
-      taskId = taskArg;
+      taskId2 = taskArg;
       if (/^\d+$/.test(taskArg)) {
         const shortIdManager = new ShortIdManager();
         const resolved = await shortIdManager.resolveId(taskArg);
         if (resolved) {
-          taskId = 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"));
@@ -4993,21 +5454,21 @@ Auto-selecting the only paused task...
           console.error(chalk28.red(`Task not found: ${taskArg}`));
           process.exit(1);
         }
-        taskId = matchingTask.id;
+        taskId2 = matchingTask.id;
       }
     }
-    const task = await taskOps.getTask(taskId);
+    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 " + taskId.slice(0, 8) + "\n"));
+        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(taskId);
+    const resumedTask = await taskOps.resumeTask(taskId2);
     spinner.succeed(chalk28.green("Task resumed!"));
     console.log();
     console.log(chalk28.magenta("\u26A1 ") + chalk28.white(resumedTask.title));
@@ -5016,8 +5477,8 @@ Task is not paused (status: ${task.status}): ${task.title}
       console.log(chalk28.gray(`   Context: ${task.context_notes.split("\n").pop()?.slice(0, 60)}...`));
     }
     console.log();
-    console.log(chalk28.gray(`Complete with: vibetasks done ${taskId.slice(0, 8)}`));
-    console.log(chalk28.gray(`Pause again:   vibetasks pause ${taskId.slice(0, 8)}`));
+    console.log(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) {
@@ -5046,13 +5507,13 @@ var revertCommand = new Command28("revert").description("Revert a specific chang
     const authManager = new AuthManager27();
     const taskOps = await TaskOperations23.fromAuthManager(authManager);
     if (options.task || !changeId) {
-      let taskId;
+      let taskId2;
       if (options.task) {
         if (/^\d+$/.test(options.task)) {
           const shortIdManager = new ShortIdManager();
           const resolved = await shortIdManager.resolveId(options.task);
           if (resolved) {
-            taskId = resolved;
+            taskId2 = resolved;
           } else {
             console.error(chalk29.red(`Task #${options.task} not found`));
             process.exit(1);
@@ -5061,21 +5522,21 @@ var revertCommand = new Command28("revert").description("Revert a specific chang
           const allTasks = await taskOps.getTasks("all");
           const matchingTask = allTasks.find((t) => t.id.startsWith(options.task));
           if (matchingTask) {
-            taskId = matchingTask.id;
+            taskId2 = matchingTask.id;
           }
         } else {
-          taskId = options.task;
+          taskId2 = options.task;
         }
       }
-      if (!taskId) {
+      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(taskId, { limit: 20 });
-      const task2 = await taskOps.getTask(taskId);
+      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}
@@ -5200,12 +5661,12 @@ var blameCommand = new Command29("blame").description("Show who changed what on
   try {
     const authManager = new AuthManager28();
     const taskOps = await TaskOperations24.fromAuthManager(authManager);
-    let taskId = taskArg;
+    let taskId2 = taskArg;
     if (/^\d+$/.test(taskArg)) {
       const shortIdManager = new ShortIdManager();
       const resolved = await shortIdManager.resolveId(taskArg);
       if (resolved) {
-        taskId = 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"));
@@ -5218,10 +5679,10 @@ var blameCommand = new Command29("blame").description("Show who changed what on
         console.error(chalk30.red(`Task not found: ${taskArg}`));
         process.exit(1);
       }
-      taskId = matchingTask.id;
+      taskId2 = matchingTask.id;
     }
-    const task = await taskOps.getTask(taskId);
-    const changes = await taskOps.getTaskChanges(taskId, { limit: 100 });
+    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}
@@ -5257,7 +5718,7 @@ No change history for task: ${task.title}
     }
     console.log();
     console.log(chalk30.cyan.bold(`Blame for: ${task.title}`));
-    console.log(chalk30.gray(`Task ID: ${taskId}`));
+    console.log(chalk30.gray(`Task ID: ${taskId2}`));
     console.log();
     const fields = options.field ? [options.field] : Object.keys(blameMap).sort();
     if (fields.length === 0) {
@@ -5300,7 +5761,7 @@ No change history for task: ${task.title}
     console.log(chalk30.gray("\u2500".repeat(50)));
     console.log(chalk30.gray(`Total changes: ${totalChanges} | \u{1F916} AI: ${aiChanges} | \u{1F464} Human: ${humanChanges}`));
     console.log(chalk30.gray(`
-Full history: vibetasks log ${taskId.slice(0, 8)}`));
+Full history: vibetasks log ${taskId2.slice(0, 8)}`));
     console.log();
     process.exit(0);
   } catch (error) {
@@ -5326,10 +5787,1068 @@ function formatValue3(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 Command30();
+var program = new Command37();
 program.name("vibetasks").description("VibeTasks CLI - Fast task management for vibers").version(pkg.version);
 program.addCommand(setupCommand);
 program.addCommand(loginCommand);
@@ -5361,4 +6880,11 @@ 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();