task-memory 0.3.0

package/dist/index.js

@@ -0,0 +1,2708 @@
+#!/usr/bin/env node
+
+// src/store.ts
+import { join, resolve, dirname } from "path";
+import { homedir } from "os";
+import { existsSync, readFileSync, writeFileSync, statSync } from "fs";
+
+// src/utils/orderUtils.ts
+function parseOrder(order) {
+  if (!order || order === "") {
+    return [];
+  }
+  return order.split("-").map((s) => parseFloat(s));
+}
+function formatOrder(parts) {
+  if (parts.length === 0) {
+    return "";
+  }
+  return parts.map((n) => String(n)).join("-");
+}
+function compareOrders(a, b) {
+  if (a == null && b == null)
+    return 0;
+  if (a == null)
+    return 1;
+  if (b == null)
+    return -1;
+  const partsA = parseOrder(a);
+  const partsB = parseOrder(b);
+  const maxLen = Math.max(partsA.length, partsB.length);
+  for (let i = 0;i < maxLen; i++) {
+    if (i >= partsA.length)
+      return -1;
+    if (i >= partsB.length)
+      return 1;
+    if (partsA[i] !== partsB[i]) {
+      return partsA[i] - partsB[i];
+    }
+  }
+  return 0;
+}
+function normalizeOrders(orders, tiebreakers) {
+  const indexed = orders.map((order, index) => ({ order, index }));
+  const nonNull = indexed.filter((item) => item.order != null && item.order !== "");
+  if (nonNull.length === 0) {
+    return orders.map((o) => o == null ? null : o);
+  }
+  const parsed = nonNull.map((item) => ({
+    index: item.index,
+    parts: parseOrder(item.order),
+    originalOrder: item.order
+  }));
+  parsed.sort((a, b) => {
+    const orderCmp = compareOrders(a.originalOrder, b.originalOrder);
+    if (orderCmp !== 0)
+      return orderCmp;
+    if (tiebreakers) {
+      const prioA = tiebreakers[a.index] ?? 0;
+      const prioB = tiebreakers[b.index] ?? 0;
+      return prioB - prioA;
+    }
+    return 0;
+  });
+  const explicitCountBySlot = new Map;
+  const implicitOnlySlots = new Set;
+  for (const item of parsed) {
+    const parentKey = item.parts.length === 1 ? "" : formatOrder(item.parts.slice(0, -1));
+    const childNum = item.parts[item.parts.length - 1];
+    const slotKey = `${parentKey}::${childNum}`;
+    explicitCountBySlot.set(slotKey, (explicitCountBySlot.get(slotKey) ?? 0) + 1);
+    for (let len = 1;len < item.parts.length; len++) {
+      const pKey = len === 1 ? "" : formatOrder(item.parts.slice(0, len - 1));
+      const cNum = item.parts[len - 1];
+      const implicitKey = `${pKey}::${cNum}`;
+      if (!explicitCountBySlot.has(implicitKey)) {
+        implicitOnlySlots.add(implicitKey);
+      }
+    }
+  }
+  const slotsByParent = new Map;
+  for (const [slotKey, count] of explicitCountBySlot.entries()) {
+    const sep = slotKey.lastIndexOf("::");
+    const pKey = slotKey.slice(0, sep);
+    const cNum = parseFloat(slotKey.slice(sep + 2));
+    if (!slotsByParent.has(pKey))
+      slotsByParent.set(pKey, new Map);
+    slotsByParent.get(pKey).set(cNum, count);
+  }
+  for (const slotKey of implicitOnlySlots) {
+    const sep = slotKey.lastIndexOf("::");
+    const pKey = slotKey.slice(0, sep);
+    const cNum = parseFloat(slotKey.slice(sep + 2));
+    if (!slotsByParent.has(pKey))
+      slotsByParent.set(pKey, new Map);
+    if (!slotsByParent.get(pKey).has(cNum)) {
+      slotsByParent.get(pKey).set(cNum, 0);
+    }
+  }
+  const renumberMap = new Map;
+  for (const [pKey, slots] of slotsByParent.entries()) {
+    const sorted = Array.from(slots.keys()).sort((a, b) => a - b);
+    const mapping = new Map;
+    let newNum = 1;
+    for (const oldNum of sorted) {
+      const count = slots.get(oldNum);
+      const newNums = [];
+      const occurrences = count === 0 ? 1 : count;
+      for (let i = 0;i < occurrences; i++) {
+        newNums.push(newNum++);
+      }
+      mapping.set(oldNum, newNums);
+    }
+    renumberMap.set(pKey, mapping);
+  }
+  const normalizedMap = new Map;
+  const occurrenceTracker = new Map;
+  for (const item of parsed) {
+    const newParts = [];
+    for (let i = 0;i < item.parts.length; i++) {
+      const originalParentKey = i === 0 ? "" : formatOrder(item.parts.slice(0, i));
+      const oldNum = item.parts[i];
+      const mapping = renumberMap.get(originalParentKey);
+      if (!mapping) {
+        throw new Error(`Internal error: no renumbering map for parent ${originalParentKey}`);
+      }
+      const newNums = mapping.get(oldNum);
+      if (newNums === undefined || newNums.length === 0) {
+        throw new Error(`Internal error: no new number for ${oldNum} in parent ${originalParentKey}`);
+      }
+      const isLeaf = i === item.parts.length - 1;
+      if (isLeaf && newNums.length > 1) {
+        const trackerKey = `${originalParentKey}::${oldNum}`;
+        const occIdx = occurrenceTracker.get(trackerKey) ?? 0;
+        occurrenceTracker.set(trackerKey, occIdx + 1);
+        newParts.push(newNums[occIdx] ?? newNums[newNums.length - 1]);
+      } else {
+        newParts.push(newNums[0]);
+      }
+    }
+    normalizedMap.set(item.index, formatOrder(newParts));
+  }
+  return orders.map((o, index) => {
+    if (o == null)
+      return null;
+    return normalizedMap.get(index) ?? o;
+  });
+}
+function sortByOrder(items, getOrder, getId) {
+  return [...items].sort((a, b) => {
+    const orderA = getOrder(a);
+    const orderB = getOrder(b);
+    const cmp = compareOrders(orderA, orderB);
+    if (cmp !== 0)
+      return cmp;
+    const idA = getId(a);
+    const idB = getId(b);
+    const numA = parseInt(idA.replace(/\D/g, ""), 10) || 0;
+    const numB = parseInt(idB.replace(/\D/g, ""), 10) || 0;
+    return numA - numB;
+  });
+}
+
+// src/store.ts
+function findGitPath(startDir) {
+  let currentDir = startDir;
+  const home = homedir();
+  while (true) {
+    const gitPath = join(currentDir, ".git");
+    if (existsSync(gitPath)) {
+      return gitPath;
+    }
+    if (currentDir === home) {
+      return null;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+function getDbPath() {
+  if (process.env.TASK_MEMORY_PATH) {
+    return resolve(process.cwd(), process.env.TASK_MEMORY_PATH);
+  }
+  const gitPath = findGitPath(process.cwd());
+  if (gitPath) {
+    let isGitDir = false;
+    try {
+      isGitDir = statSync(gitPath).isDirectory();
+    } catch {}
+    if (isGitDir) {
+      const gitTaskMemory = join(gitPath, "task-memory.json");
+      if (existsSync(gitTaskMemory)) {
+        return gitTaskMemory;
+      }
+    }
+    const projectDir = dirname(gitPath);
+    const taskMemoryPath = join(projectDir, "task-memory.json");
+    if (existsSync(taskMemoryPath)) {
+      return taskMemoryPath;
+    }
+    const hiddenPath = join(projectDir, ".task-memory.json");
+    if (existsSync(hiddenPath)) {
+      return hiddenPath;
+    }
+    if (isGitDir) {
+      return join(gitPath, "task-memory.json");
+    }
+    return taskMemoryPath;
+  }
+  return join(homedir(), ".task-memory.json");
+}
+var DB_PATH = getDbPath();
+var cachedStore = null;
+var afterSaveCallback = null;
+function setAfterSaveCallback(callback) {
+  afterSaveCallback = callback;
+}
+function loadStore() {
+  if (!existsSync(DB_PATH)) {
+    return { tasks: [] };
+  }
+  try {
+    const data = readFileSync(DB_PATH, "utf-8");
+    const parsed = JSON.parse(data);
+    if (Array.isArray(parsed)) {
+      return { tasks: parsed };
+    }
+    return parsed;
+  } catch (e) {
+    console.error(`Error loading store from ${DB_PATH}:`, e);
+    return { tasks: [] };
+  }
+}
+function saveStore(store) {
+  try {
+    writeFileSync(DB_PATH, JSON.stringify(store, null, 2), "utf-8");
+    cachedStore = store;
+    if (afterSaveCallback) {
+      afterSaveCallback(store);
+    }
+  } catch (e) {
+    console.error(`Error saving store to ${DB_PATH}:`, e);
+  }
+}
+function loadTasks() {
+  const store = loadStore();
+  cachedStore = store;
+  return store.tasks;
+}
+function normalizeTaskOrders(tasks) {
+  const activeIndices = [];
+  const activeOrders = [];
+  const activeTiebreakers = [];
+  tasks.forEach((task, index) => {
+    if (task.status === "todo" || task.status === "wip") {
+      activeIndices.push(index);
+      activeOrders.push(task.order ?? null);
+      activeTiebreakers.push(new Date(task.updated_at || 0).getTime());
+    }
+  });
+  const normalizedOrders = normalizeOrders(activeOrders, activeTiebreakers);
+  const result = tasks.map((task, index) => {
+    if (task.status === "todo" || task.status === "wip") {
+      const activeIndex = activeIndices.indexOf(index);
+      if (activeIndex !== -1) {
+        const newOrder = normalizedOrders[activeIndex];
+        if (task.order !== newOrder) {
+          return { ...task, order: newOrder };
+        }
+      }
+      return task;
+    } else {
+      if (task.order != null) {
+        return { ...task, order: null };
+      }
+      return task;
+    }
+  });
+  return result;
+}
+function saveTasks(tasks) {
+  const store = cachedStore || loadStore();
+  store.tasks = normalizeTaskOrders(tasks);
+  saveStore(store);
+}
+function loadSyncConfig() {
+  const store = cachedStore || loadStore();
+  return store.sync;
+}
+function saveSyncConfig(sync) {
+  const store = cachedStore || loadStore();
+  store.sync = sync;
+  saveStore(store);
+}
+function getTaskById(tasks, idOrIndex) {
+  if (typeof idOrIndex === "number") {
+    const targetId = `TASK-${idOrIndex}`;
+    return tasks.find((t) => t.id === targetId);
+  }
+  const idStr = idOrIndex.toString();
+  if (idStr.match(/^\d+$/)) {
+    return tasks.find((t) => t.id === `TASK-${idStr}`);
+  }
+  return tasks.find((t) => t.id === idStr);
+}
+function getNextId(tasks) {
+  let max = 0;
+  for (const task of tasks) {
+    const match = task.id.match(/^TASK-(\d+)$/);
+    if (match) {
+      const num = parseInt(match[1], 10);
+      if (num > max)
+        max = num;
+    }
+  }
+  return `TASK-${max + 1}`;
+}
+
+// src/utils/taskBuilder.ts
+function parseTaskArgs(args) {
+  const summaryParts = [];
+  let status = "todo";
+  let priority;
+  let goal;
+  let order;
+  const bodies = [];
+  const addFiles = [];
+  const readFiles = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg.startsWith("-")) {
+      switch (arg) {
+        case "--status":
+        case "-s":
+          const s = args[i + 1];
+          if (s && !s.startsWith("-")) {
+            if (["todo", "wip", "done", "pending", "long", "closed"].includes(s)) {
+              status = s;
+              i++;
+            } else {
+              throw new Error(`Invalid status '${s}'. Allowed: todo, wip, done, pending, long, closed.`);
+            }
+          } else {
+            throw new Error("--status requires a value.");
+          }
+          break;
+        case "--goal":
+        case "-g":
+          const g = args[i + 1];
+          if (g && !g.startsWith("-")) {
+            goal = g;
+            i++;
+          } else {
+            throw new Error("--goal requires a value.");
+          }
+          break;
+        case "--priority":
+        case "-p":
+          const p = args[i + 1];
+          if (p && !p.startsWith("-")) {
+            priority = p;
+            i++;
+          } else {
+            throw new Error("--priority requires a value.");
+          }
+          break;
+        case "--order":
+        case "-o":
+          const o = args[i + 1];
+          if (o && !o.startsWith("-")) {
+            order = o === "null" ? null : o;
+            i++;
+          } else {
+            throw new Error("--order requires a value.");
+          }
+          break;
+        case "--body":
+        case "-b":
+          const b = args[i + 1];
+          if (b && !b.startsWith("-")) {
+            bodies.push(b);
+            i++;
+          } else {
+            throw new Error("--body requires a value.");
+          }
+          break;
+        case "--add-file":
+        case "-a":
+          const af = args[i + 1];
+          if (af && !af.startsWith("-")) {
+            addFiles.push(af);
+            i++;
+          } else {
+            throw new Error("--add-file requires a path.");
+          }
+          break;
+        case "--read-file":
+        case "-r":
+          const rf = args[i + 1];
+          if (rf && !rf.startsWith("-")) {
+            readFiles.push(rf);
+            i++;
+          } else {
+            throw new Error("--read-file requires a path.");
+          }
+          break;
+        default:
+          throw new Error(`Unknown option '${arg}'.`);
+      }
+    } else {
+      summaryParts.push(arg);
+    }
+  }
+  return {
+    summary: summaryParts.join(" ") || undefined,
+    status,
+    priority,
+    goal,
+    order,
+    bodies,
+    addFiles,
+    readFiles
+  };
+}
+function buildTask(id, options) {
+  const now = new Date().toISOString();
+  const status = options.status || "todo";
+  const order = status === "todo" || status === "wip" ? options.order ?? null : null;
+  return {
+    id,
+    status,
+    priority: options.priority,
+    version: options.version || "tbd",
+    goal: options.goal,
+    order,
+    summary: options.summary || "",
+    bodies: (options.bodies || []).map((text) => ({ text, created_at: now })),
+    files: {
+      read: options.readFiles || [],
+      edit: options.addFiles || []
+    },
+    created_at: now,
+    updated_at: now
+  };
+}
+
+// src/commands/new.ts
+function newCommand(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+Usage: tm new <summary> [options]
+
+Options:
+  --status, -s <status>    Set initial status (todo, wip, done, pending, long, closed)
+  --priority, -p <value>   Set priority
+  --goal, -g <text>        Set completion goal
+  --order, -o <value>      Set progress order (e.g., 1, 1-1, 2-3)
+  --body, -b <text>        Add initial body text
+  --add-file, -a <path>    Add editable file
+  --read-file, -r <path>   Add read-only file
+`);
+    return;
+  }
+  let options;
+  try {
+    options = parseTaskArgs(args);
+  } catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    return;
+  }
+  if (!options.summary) {
+    console.error("Error: Task summary is required. Usage: tm new <summary> [options]");
+    return;
+  }
+  const tasks = loadTasks();
+  const id = getNextId(tasks);
+  const newTask = buildTask(id, options);
+  tasks.push(newTask);
+  saveTasks(tasks);
+  console.log(`${id} ${options.summary}`);
+}
+
+// src/reviewStore.ts
+import { join as join2, dirname as dirname2 } from "path";
+import { homedir as homedir2 } from "os";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, statSync as statSync2 } from "fs";
+function getReviewDbPath() {
+  if (process.env.REVIEW_MEMORY_PATH) {
+    return process.env.REVIEW_MEMORY_PATH;
+  }
+  const gitPath = findGitPath(process.cwd());
+  if (gitPath) {
+    let isGitDir = false;
+    try {
+      isGitDir = statSync2(gitPath).isDirectory();
+    } catch {}
+    if (isGitDir) {
+      return join2(gitPath, "review-memory.json");
+    }
+    return join2(dirname2(gitPath), "review-memory.json");
+  }
+  return join2(homedir2(), ".review-memory.json");
+}
+var DB_PATH2 = getReviewDbPath();
+function loadReviews() {
+  if (!existsSync2(DB_PATH2)) {
+    return [];
+  }
+  try {
+    const data = readFileSync2(DB_PATH2, "utf-8");
+    const store = JSON.parse(data);
+    if (Array.isArray(store)) {
+      return store;
+    }
+    return store.reviews || [];
+  } catch (e) {
+    console.error(`Error loading reviews from ${DB_PATH2}:`, e);
+    return [];
+  }
+}
+function saveReviews(reviews) {
+  try {
+    writeFileSync2(DB_PATH2, JSON.stringify(reviews, null, 2), "utf-8");
+  } catch (e) {
+    console.error(`Error saving reviews to ${DB_PATH2}:`, e);
+  }
+}
+function getReviewById(reviews, idOrIndex) {
+  if (typeof idOrIndex === "number") {
+    const targetId = `REVIEW-${idOrIndex}`;
+    return reviews.find((r) => r.id === targetId);
+  }
+  const idStr = idOrIndex.toString();
+  if (idStr.match(/^\d+$/)) {
+    return reviews.find((r) => r.id === `REVIEW-${idStr}`);
+  }
+  return reviews.find((r) => r.id === idStr);
+}
+function getNextReviewId(reviews) {
+  let max = 0;
+  for (const review of reviews) {
+    const match = review.id.match(/^REVIEW-(\d+)$/);
+    if (match) {
+      const num = parseInt(match[1], 10);
+      if (num > max)
+        max = num;
+    }
+  }
+  return `REVIEW-${max + 1}`;
+}
+
+// src/commands/list.ts
+function listCommand(args = []) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+Usage: tm list [options]
+
+Options:
+  --status-all, -a Show all tasks (including done/closed)
+  --open           Show all open tasks (todo, wip, pending, long)
+  --priority <p>   Filter by priority
+  --status, -s <s> Filter by status
+  --version <v>    Filter by version
+  --tbd            Filter by version 'tbd' (includes closed/done)
+  --released       Filter by released tasks (non-tbd version, includes closed/done)
+  --sort <key>     Sort by: order (default), id, created
+  --head [N]       Show first N tasks (default: 10)
+  --tail [N]       Show last N tasks (default: 10)
+`);
+    return;
+  }
+  function parseNumericOption(optionName, defaultValue) {
+    const index = args.indexOf(optionName);
+    if (index === -1)
+      return null;
+    const nextArg = args[index + 1];
+    if (nextArg && !nextArg.startsWith("-")) {
+      const parsed = parseInt(nextArg, 10);
+      return isNaN(parsed) ? defaultValue : parsed;
+    }
+    return defaultValue;
+  }
+  let showAll = false;
+  let showOpen = false;
+  let filterPriority = null;
+  let filterStatus = null;
+  let filterVersion = null;
+  let released = false;
+  let sortBy = "order";
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--status-all":
+      case "-a":
+        showAll = true;
+        break;
+      case "--open":
+        showOpen = true;
+        break;
+      case "--priority":
+        if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+          filterPriority = args[++i];
+        } else {
+          console.error("Error: --priority requires a value.");
+          return;
+        }
+        break;
+      case "--status":
+      case "-s":
+        if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+          filterStatus = args[++i];
+        } else {
+          console.error("Error: --status requires a value.");
+          return;
+        }
+        break;
+      case "--version":
+        if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+          filterVersion = args[++i];
+        } else {
+          console.error("Error: --version requires a value.");
+          return;
+        }
+        break;
+      case "--tbd":
+        filterVersion = "tbd";
+        showAll = true;
+        break;
+      case "--released":
+        released = true;
+        showAll = true;
+        break;
+      case "--sort":
+        if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+          const sortValue = args[++i];
+          if (sortValue === "order" || sortValue === "id" || sortValue === "created") {
+            sortBy = sortValue;
+          } else {
+            console.error(`Error: Invalid sort key '${sortValue}'. Allowed: order, id, created.`);
+            return;
+          }
+        } else {
+          console.error("Error: --sort requires a value.");
+          return;
+        }
+        break;
+      case "--head":
+      case "--tail":
+        const nextArg = args[i + 1];
+        if (nextArg && !nextArg.startsWith("-")) {
+          i++;
+        }
+        break;
+      default:
+        if (arg.startsWith("--")) {
+          console.error(`Error: Unknown option '${arg}'.`);
+          return;
+        } else if (!arg.match(/^\d+$/)) {
+          console.error(`Error: Unknown argument '${arg}'.`);
+          return;
+        }
+        break;
+    }
+  }
+  const headCount = parseNumericOption("--head", 10);
+  const tailCount = parseNumericOption("--tail", 10);
+  const tasks = loadTasks();
+  const activeTasks = tasks.filter((t) => {
+    if (filterPriority && t.priority !== filterPriority)
+      return false;
+    if (filterStatus && t.status !== filterStatus)
+      return false;
+    if (filterVersion && t.version !== filterVersion)
+      return false;
+    if (released) {
+      if (!t.version || t.version === "tbd" || t.version === "")
+        return false;
+    }
+    if (filterStatus)
+      return true;
+    if (showAll)
+      return true;
+    if (t.status === "done" || t.status === "closed")
+      return false;
+    if (!showOpen && (t.status === "pending" || t.status === "long"))
+      return false;
+    return true;
+  });
+  let sortedTasks = activeTasks;
+  switch (sortBy) {
+    case "order":
+      sortedTasks = sortByOrder(activeTasks, (t) => t.order ?? null, (t) => t.id);
+      break;
+    case "id":
+      sortedTasks = [...activeTasks].sort((a, b) => {
+        const numA = parseInt(a.id.replace(/\D/g, ""), 10) || 0;
+        const numB = parseInt(b.id.replace(/\D/g, ""), 10) || 0;
+        return numA - numB;
+      });
+      break;
+    case "created":
+      sortedTasks = [...activeTasks].sort((a, b) => {
+        return a.created_at.localeCompare(b.created_at);
+      });
+      break;
+  }
+  const reviews = loadReviews();
+  const checkingReviews = reviews.filter((r) => r.status === "checking");
+  let displayTasks = sortedTasks;
+  let displayReviews = checkingReviews;
+  if (headCount !== null) {
+    displayTasks = sortedTasks.slice(0, headCount);
+    const remaining = headCount - displayTasks.length;
+    displayReviews = remaining > 0 ? checkingReviews.slice(0, remaining) : [];
+  } else if (tailCount !== null) {
+    const totalLength = sortedTasks.length + checkingReviews.length;
+    const startIndex = Math.max(0, totalLength - tailCount);
+    const tasksToSkip = Math.min(startIndex, sortedTasks.length);
+    displayTasks = sortedTasks.slice(tasksToSkip);
+    const reviewsToSkip = Math.max(0, startIndex - sortedTasks.length);
+    displayReviews = checkingReviews.slice(reviewsToSkip);
+  }
+  if (displayTasks.length === 0 && displayReviews.length === 0) {
+    return;
+  }
+  displayTasks.forEach((task) => {
+    const match = task.id.match(/^TASK-(\d+)$/);
+    const displayId = match ? match[1] : task.id;
+    const priorityStr = task.priority ? ` (Priority: ${task.priority})` : "";
+    let versionStr = "";
+    if (task.version && task.version !== "tbd") {
+      versionStr = ` [v:${task.version}]`;
+    }
+    console.log(`${displayId}: ${task.summary} [${task.status}]${priorityStr}${versionStr}`);
+  });
+  displayReviews.forEach((review) => {
+    console.log(`${review.id}: ${review.title} [${review.status}]`);
+  });
+}
+
+// src/commands/get.ts
+function getCommand(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+Usage: tm get <id...> [options]
+
+Options:
+  --all, -a, --history     Show full history of bodies
+`);
+    return;
+  }
+  const showAllHistory = args.includes("--all") || args.includes("-a") || args.includes("--history");
+  const ids = [];
+  for (const arg of args) {
+    if (arg.startsWith("-")) {
+      if (arg !== "--all" && arg !== "-a" && arg !== "--history") {
+        console.error(`Error: Unknown option '${arg}'.`);
+        return;
+      }
+    } else {
+      ids.push(arg);
+    }
+  }
+  if (ids.length === 0) {
+    console.error("Error: Task ID is required. Usage: tm get <id...> [options]");
+    return;
+  }
+  const tasks = loadTasks();
+  const result = [];
+  for (const id of ids) {
+    const task = getTaskById(tasks, id);
+    if (task) {
+      const taskOutput = { ...task };
+      if (!showAllHistory && task.bodies.length > 0) {
+        const lastBody = task.bodies[task.bodies.length - 1];
+        if (lastBody) {
+          taskOutput.bodies = [lastBody];
+        }
+      }
+      result.push(taskOutput);
+    } else {
+      console.error(`Error: ID '${id}' not found.`);
+    }
+  }
+  console.log(JSON.stringify(result, null, 2));
+}
+
+// src/commands/finish.ts
+function finishCommand(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+Usage: tm finish <id...> [options]
+
+Options:
+  --body <body>    Add a closing comment
+`);
+    return;
+  }
+  if (args.length === 0) {
+    console.error("Error: Task ID is required. Usage: tm finish <id...> [--body <body>]");
+    return;
+  }
+  const tasks = loadTasks();
+  let currentTargetIds = [];
+  let updated = false;
+  let lastActionWasOption = false;
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg.startsWith("--")) {
+      lastActionWasOption = true;
+      if (arg === "--body") {
+        if (currentTargetIds.length === 0) {
+          console.error("Error: --body must be preceded by at least one task ID.");
+          return;
+        }
+        const bodyText = args[++i];
+        if (bodyText) {
+          const now = new Date().toISOString();
+          for (const id of currentTargetIds) {
+            const task = getTaskById(tasks, id);
+            if (task) {
+              task.bodies.push({ text: bodyText, created_at: now });
+              task.updated_at = now;
+            }
+          }
+        } else {
+          console.error("Error: --body requires a text argument.");
+        }
+      } else {
+        console.error(`Error: Unknown option '${arg}'.`);
+        return;
+      }
+    } else {
+      if (lastActionWasOption) {
+        currentTargetIds = [];
+        lastActionWasOption = false;
+      }
+      const id = arg;
+      const task = getTaskById(tasks, id);
+      if (task) {
+        if (task.status !== "done") {
+          task.status = "done";
+          task.updated_at = new Date().toISOString();
+          console.log(`Task ${task.id} marked as done.`);
+          updated = true;
+        } else {
+          console.log(`Task ${task.id} is already done.`);
+        }
+        currentTargetIds.push(id);
+      } else {
+        console.error(`Error: ID '${id}' not found.`);
+      }
+    }
+  }
+  if (updated) {
+    saveTasks(tasks);
+  }
+}
+
+// src/commands/update.ts
+function updateCommand(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+Usage: tm update <id...> [options]
+
+Options:
+  --status, -s <status>    Update status (todo, wip, done, pending, long, closed)
+  --priority, -p <value>   Update priority
+  --version, -v <value>    Update version
+  --goal, -g <text>        Update completion goal
+  --order, -o <value>      Update progress order (use 'null' to clear)
+  --body, -b <text>        Append body text
+  --add-file, -a <path>    Add editable file
+  --rm-file, -d <path>     Remove editable file
+  --read-file, -r <path>   Add read-only file
+`);
+    return;
+  }
+  const tasks = loadTasks();
+  let currentTargetIds = [];
+  let updated = false;
+  let lastActionWasOption = false;
+  const applyUpdate = (action) => {
+    if (currentTargetIds.length === 0) {
+      console.error("Error: No task ID specified for update. Usage: tm update <id> [options] ...");
+      return;
+    }
+    for (const id of currentTargetIds) {
+      const task = getTaskById(tasks, id);
+      if (task) {
+        action(task);
+        task.updated_at = new Date().toISOString();
+        updated = true;
+      } else {
+        console.error(`Error: ID '${id}' not found.`);
+      }
+    }
+  };
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg.startsWith("-")) {
+      lastActionWasOption = true;
+      switch (arg) {
+        case "--status":
+        case "-s":
+          const status = args[++i];
+          if (status && ["todo", "wip", "done", "pending", "long", "closed"].includes(status)) {
+            applyUpdate((t) => {
+              t.status = status;
+              if (status !== "todo" && status !== "wip") {
+                t.order = null;
+              }
+            });
+          } else {
+            console.error(`Error: Invalid status '${status}'. Allowed: todo, wip, done, pending, long, closed.`);
+          }
+          break;
+        case "--priority":
+        case "-p":
+          const priority = args[++i];
+          if (priority) {
+            applyUpdate((t) => t.priority = priority);
+          } else {
+            console.error("Error: --priority requires a value.");
+          }
+          break;
+        case "--version":
+        case "-v":
+          const version = args[++i];
+          if (version) {
+            applyUpdate((t) => t.version = version);
+          } else {
+            console.error("Error: --version requires a value.");
+          }
+          break;
+        case "--goal":
+        case "-g":
+          const goal = args[++i];
+          if (goal) {
+            applyUpdate((t) => t.goal = goal);
+          } else {
+            console.error("Error: --goal requires a value.");
+          }
+          break;
+        case "--order":
+        case "-o":
+          const order = args[++i];
+          if (order) {
+            applyUpdate((t) => {
+              if (t.status === "todo" || t.status === "wip") {
+                t.order = order === "null" ? null : order;
+              } else {
+                console.error(`Error: Cannot set order for task with status '${t.status}'. Only todo/wip allowed.`);
+              }
+            });
+          } else {
+            console.error("Error: --order requires a value.");
+          }
+          break;
+        case "--body":
+        case "-b":
+          const bodyText = args[++i];
+          if (bodyText) {
+            applyUpdate((t) => t.bodies.push({
+              text: bodyText,
+              created_at: new Date().toISOString()
+            }));
+          } else {
+            console.error("Error: --body requires a text argument.");
+          }
+          break;
+        case "--add-file":
+        case "-a":
+          const addPath = args[++i];
+          if (addPath) {
+            applyUpdate((t) => {
+              if (!t.files.edit.includes(addPath)) {
+                t.files.edit.push(addPath);
+              }
+            });
+          } else {
+            console.error("Error: --add-file requires a path argument.");
+          }
+          break;
+        case "--rm-file":
+        case "-d":
+          const rmPath = args[++i];
+          if (rmPath) {
+            applyUpdate((t) => {
+              t.files.edit = t.files.edit.filter((p) => p !== rmPath);
+            });
+          } else {
+            console.error("Error: --rm-file requires a path argument.");
+          }
+          break;
+        case "--read-file":
+        case "-r":
+          const readPath = args[++i];
+          if (readPath) {
+            applyUpdate((t) => {
+              if (!t.files.read.includes(readPath)) {
+                t.files.read.push(readPath);
+              }
+            });
+          } else {
+            console.error("Error: --read-file requires a path argument.");
+          }
+          break;
+        default:
+          console.error(`Error: Unknown option '${arg}'.`);
+          return;
+      }
+    } else {
+      if (lastActionWasOption) {
+        currentTargetIds = [];
+        lastActionWasOption = false;
+      }
+      currentTargetIds.push(arg);
+    }
+  }
+  if (updated) {
+    saveTasks(tasks);
+    console.log("Tasks updated.");
+  }
+}
+
+// src/commands/env.ts
+function envCommand(args = []) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+Usage: tm env
+
+Description:
+  Show the current task data file path.
+`);
+    return;
+  }
+  if (args.length > 0) {
+    console.error(`Error: env command doesn't accept arguments.`);
+    return;
+  }
+  console.log(getDbPath());
+}
+
+// src/commands/review.ts
+function reviewCommand(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+Usage: tm review <command> [args]
+
+Commands:
+  new <title> --body <body>
+  list
+  get <id> [--history]
+  update <id> [--status <status> --body <body>]
+  return <id> [--status <status> --body <body>]
+  accept <id> [--new <summary>...]
+  reject <id>
+`);
+    return;
+  }
+  const subcommand = args[0];
+  const subArgs = args.slice(1);
+  switch (subcommand) {
+    case "new":
+      handleNew(subArgs);
+      break;
+    case "list":
+      handleList();
+      break;
+    case "get":
+      handleGet(subArgs);
+      break;
+    case "update":
+      handleUpdate(subArgs);
+      break;
+    case "return":
+      handleReturn(subArgs);
+      break;
+    case "accept":
+      handleAccept(subArgs);
+      break;
+    case "reject":
+      handleReject(subArgs);
+      break;
+    default:
+      console.error(`Unknown review subcommand: ${subcommand}`);
+      console.log(`
+Usage: tm review <command> [args]
+
+Commands:
+  new <title> --body <body>
+  list
+  get <id> [--history]
+  update <id> [--status <status> --body <body>]
+  return <id> [--status <status> --body <body>]
+  accept <id> [--new <summary>...]
+  reject <id>
+`);
+      process.exit(1);
+  }
+}
+function handleNew(args) {
+  let title = "";
+  let body = "";
+  const titleParts = [];
+  let i = 0;
+  while (i < args.length) {
+    if (args[i].startsWith("--"))
+      break;
+    titleParts.push(args[i]);
+    i++;
+  }
+  title = titleParts.join(" ");
+  while (i < args.length) {
+    if (args[i] === "--body") {
+      body = args[i + 1] || "";
+      i += 2;
+    } else if (args[i].startsWith("--")) {
+      console.error(`Error: Unknown option '${args[i]}'.`);
+      return;
+    } else {
+      console.error(`Error: Unknown argument '${args[i]}'.`);
+      return;
+    }
+  }
+  if (!title) {
+    console.error("Error: Title is required");
+    return;
+  }
+  const reviews = loadReviews();
+  const newId = getNextReviewId(reviews);
+  const now = new Date().toISOString();
+  const newReview = {
+    id: newId,
+    title,
+    bodies: [{ text: body, created_at: now }],
+    status: "todo",
+    created_at: now,
+    updated_at: now
+  };
+  reviews.push(newReview);
+  saveReviews(reviews);
+  console.log(`Created review ${newId}`);
+}
+function handleList() {
+  const reviews = loadReviews();
+  const activeReviews = reviews.filter((r) => r.status !== "closed" && r.status !== "done");
+  if (activeReviews.length === 0) {
+    console.log("No active reviews.");
+    return;
+  }
+  console.log("ID\tStatus\tTitle");
+  console.log("--\t------\t-----");
+  activeReviews.forEach((r) => {
+    console.log(`${r.id}	${r.status}	${r.title}`);
+  });
+}
+function handleGet(args) {
+  const id = args[0];
+  const showHistory = args.includes("--history") || args.includes("--all");
+  if (!id) {
+    console.error("Error: Review ID is required");
+    process.exit(1);
+  }
+  const reviews = loadReviews();
+  const review = getReviewById(reviews, id);
+  if (!review) {
+    console.error(`Error: Review ${id} not found`);
+    process.exit(1);
+  }
+  if (showHistory) {
+    console.log(JSON.stringify(review, null, 2));
+    return;
+  }
+  console.log(`Review: ${review.title}`);
+  console.log(`ID: ${review.id}`);
+  console.log(`Status: ${review.status}`);
+  console.log("---");
+  console.log("Description:");
+  const description = review.bodies[0]?.text || "";
+  console.log(description);
+  if (review.bodies.length > 1) {
+    console.log(`
+Answers:`);
+    review.bodies.slice(1).forEach((b, i) => {
+      console.log(`
+[${i + 1}] ${b.created_at}`);
+      console.log(b.text);
+    });
+  }
+  console.log(`
+To reply to this review, run:
+tm review return ${id} --body "Your reply here"`);
+}
+function handleUpdate(args) {
+  const id = args[0];
+  if (!id || id.startsWith("--")) {
+    console.error("Error: Review ID is required");
+    process.exit(1);
+  }
+  const reviews = loadReviews();
+  const review = getReviewById(reviews, id);
+  if (!review) {
+    console.error(`Error: Review ${id} not found`);
+    process.exit(1);
+  }
+  let status;
+  let body;
+  let i = 1;
+  while (i < args.length) {
+    if (args[i] === "--status") {
+      const newStatus = args[i + 1];
+      const validStatuses = ["todo", "wip", "checking", "closed", "done", "pending"];
+      if (!validStatuses.includes(newStatus)) {
+        console.error(`Error: Invalid status '${newStatus}'. Valid statuses are: ${validStatuses.join(", ")}`);
+        process.exit(1);
+      }
+      status = newStatus;
+      i += 2;
+    } else if (args[i] === "--body") {
+      body = args[i + 1];
+      i += 2;
+    } else if (args[i].startsWith("--")) {
+      console.error(`Error: Unknown option '${args[i]}'.`);
+      return;
+    } else {
+      console.error(`Error: Unknown argument '${args[i]}'.`);
+      return;
+    }
+  }
+  const now = new Date().toISOString();
+  let updated = false;
+  if (status) {
+    review.status = status;
+    updated = true;
+  }
+  if (body) {
+    review.bodies.push({ text: body, created_at: now });
+    updated = true;
+  }
+  if (updated) {
+    review.updated_at = now;
+    saveReviews(reviews);
+    console.log(`Updated review ${review.id}`);
+  } else {
+    console.log("No changes made.");
+  }
+}
+function handleReturn(args) {
+  if (!args.includes("--status")) {
+    args.push("--status", "checking");
+  }
+  handleUpdate(args);
+}
+function handleAccept(args) {
+  const id = args[0];
+  if (!id || id.startsWith("--")) {
+    console.error("Error: Review ID is required");
+    process.exit(1);
+  }
+  const reviews = loadReviews();
+  const review = getReviewById(reviews, id);
+  if (!review) {
+    console.error(`Error: Review ${id} not found`);
+    process.exit(1);
+  }
+  const newTasksArgs = [];
+  let currentNewArgs = [];
+  let collectingNew = false;
+  for (let i = 1;i < args.length; i++) {
+    if (args[i] === "--new") {
+      if (collectingNew && currentNewArgs.length > 0) {
+        newTasksArgs.push([...currentNewArgs]);
+      }
+      currentNewArgs = [];
+      collectingNew = true;
+    } else if (collectingNew) {
+      if (args[i] === "--add") {
+        if (collectingNew && currentNewArgs.length > 0) {
+          newTasksArgs.push([...currentNewArgs]);
+        }
+        collectingNew = false;
+      } else {
+        currentNewArgs.push(args[i]);
+      }
+    }
+  }
+  if (collectingNew && currentNewArgs.length > 0) {
+    newTasksArgs.push([...currentNewArgs]);
+  }
+  const tasks = loadTasks();
+  const createdTaskIds = [];
+  const now = new Date().toISOString();
+  for (const taskArgs of newTasksArgs) {
+    try {
+      const options = parseTaskArgs(taskArgs);
+      if (options.summary) {
+        const newTaskId = getNextId(tasks);
+        const newTask = buildTask(newTaskId, options);
+        tasks.push(newTask);
+        createdTaskIds.push(newTaskId);
+        console.log(`Created task ${newTaskId} from review`);
+      }
+    } catch (error) {
+      console.error(`Error parsing task args: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+  }
+  if (createdTaskIds.length > 0) {
+    saveTasks(tasks);
+    review.related_task_ids = [...review.related_task_ids || [], ...createdTaskIds];
+  }
+  review.status = "done";
+  review.updated_at = now;
+  saveReviews(reviews);
+  console.log(`Review ${id} accepted and marked as done.`);
+}
+function handleReject(args) {
+  const id = args[0];
+  if (!id) {
+    console.error("Error: Review ID is required");
+    process.exit(1);
+  }
+  const reviews = loadReviews();
+  const review = getReviewById(reviews, id);
+  if (!review) {
+    console.error(`Error: Review ${id} not found`);
+    process.exit(1);
+  }
+  review.status = "closed";
+  review.updated_at = new Date().toISOString();
+  saveReviews(reviews);
+  console.log(`Review ${id} rejected and marked as closed.`);
+}
+
+// src/commands/release.ts
+function releaseCommand(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+Usage: tm release <id...> --version <v>
+
+Options:
+  --version <v>    Set version for task(s)
+`);
+    return;
+  }
+  let version = null;
+  const ids = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--version") {
+      if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+        version = args[++i];
+      } else {
+        console.error("Error: --version requires a value.");
+        return;
+      }
+    } else if (arg.startsWith("--")) {
+      console.error(`Error: Unknown option '${arg}'.`);
+      return;
+    } else {
+      ids.push(arg);
+    }
+  }
+  if (!version) {
+    console.error("Error: --version <v> is required.");
+    return;
+  }
+  if (ids.length === 0) {
+    console.error("Error: No task IDs specified.");
+    return;
+  }
+  const tasks = loadTasks();
+  let updated = false;
+  for (const id of ids) {
+    const task = getTaskById(tasks, id);
+    if (task) {
+      task.version = version;
+      task.updated_at = new Date().toISOString();
+      updated = true;
+      console.log(`Task ${id} version set to ${version}`);
+    } else {
+      console.error(`Error: Task ${id} not found.`);
+    }
+  }
+  if (updated) {
+    saveTasks(tasks);
+  }
+}
+
+// src/commands/close.ts
+function closeCommand(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+Usage: tm close <id...> [options]
+
+Options:
+  --body <body>    Add a closing comment
+`);
+    return;
+  }
+  const ids = [];
+  let bodyText = null;
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--body") {
+      if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+        bodyText = args[++i];
+      } else {
+        console.error("Error: --body requires a text argument.");
+        return;
+      }
+    } else if (arg.startsWith("--")) {
+      console.error(`Error: Unknown option '${arg}'.`);
+      return;
+    } else {
+      ids.push(arg);
+    }
+  }
+  if (ids.length === 0) {
+    console.error("Error: No task IDs provided.");
+    return;
+  }
+  const tasks = loadTasks();
+  let updatedCount = 0;
+  ids.forEach((id) => {
+    const task = getTaskById(tasks, id);
+    if (task) {
+      task.status = "closed";
+      task.updated_at = new Date().toISOString();
+      if (task.version === "tbd") {
+        task.version = "";
+      }
+      if (bodyText) {
+        const newBody = {
+          text: bodyText,
+          created_at: new Date().toISOString()
+        };
+        task.bodies.push(newBody);
+      }
+      updatedCount++;
+      console.log(`Task ${task.id} closed.`);
+    } else {
+      console.warn(`Task ${id} not found.`);
+    }
+  });
+  if (updatedCount > 0) {
+    saveTasks(tasks);
+  }
+}
+
+// src/syncStore.ts
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync3, readdirSync } from "fs";
+import { spawnSync } from "child_process";
+var SYNC_DIR = join3(homedir3(), ".local", "task-memory");
+var PROJECTS_DIR = join3(SYNC_DIR, "projects");
+var CONFIG_FILE = join3(SYNC_DIR, "config.json");
+function getSyncDir() {
+  return SYNC_DIR;
+}
+function isSyncInitialized() {
+  return existsSync3(SYNC_DIR) && existsSync3(join3(SYNC_DIR, ".git"));
+}
+function initSyncRepo() {
+  if (!existsSync3(SYNC_DIR)) {
+    mkdirSync(SYNC_DIR, { recursive: true });
+  }
+  if (!existsSync3(PROJECTS_DIR)) {
+    mkdirSync(PROJECTS_DIR, { recursive: true });
+  }
+  if (!existsSync3(join3(SYNC_DIR, ".git"))) {
+    const result = spawnSync("git", ["init"], { cwd: SYNC_DIR, stdio: "inherit" });
+    if (result.status !== 0) {
+      console.error("Failed to initialize git repository");
+      return false;
+    }
+  }
+  if (!existsSync3(CONFIG_FILE)) {
+    const config = { defaultAuto: false };
+    writeFileSync3(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+  }
+  const gitignorePath = join3(SYNC_DIR, ".gitignore");
+  if (!existsSync3(gitignorePath)) {
+    writeFileSync3(gitignorePath, `# Add patterns to ignore
+`, "utf-8");
+  }
+  return true;
+}
+function loadGlobalConfig() {
+  if (!existsSync3(CONFIG_FILE)) {
+    return { defaultAuto: false };
+  }
+  try {
+    const data = readFileSync3(CONFIG_FILE, "utf-8");
+    return JSON.parse(data);
+  } catch (e) {
+    return { defaultAuto: false };
+  }
+}
+function saveGlobalConfig(config) {
+  writeFileSync3(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+}
+function getProjectFilePath(syncId) {
+  return join3(PROJECTS_DIR, `${syncId}.json`);
+}
+function getEncryptedProjectFilePath(syncId) {
+  return join3(PROJECTS_DIR, `${syncId}.json.age`);
+}
+function getPublicKeyFromIdentityFile(keyFile) {
+  try {
+    const content = readFileSync3(keyFile, "utf-8");
+    const match = content.match(/^# public key: (.+)$/m);
+    return match ? match[1].trim() : null;
+  } catch {
+    return null;
+  }
+}
+function encryptData(data, recipient) {
+  const result = spawnSync("age", ["-e", "-r", recipient, "-a"], {
+    input: data,
+    encoding: "utf-8"
+  });
+  if (result.error) {
+    console.error(`Encryption failed: ${result.error.message}. Is 'age' command installed and in your PATH?`);
+    return null;
+  }
+  if (result.status !== 0) {
+    console.error(`Encryption failed: ${result.stderr}`);
+    return null;
+  }
+  return result.stdout;
+}
+function decryptData(ciphertext, keyFile) {
+  const result = spawnSync("age", ["-d", "-i", keyFile], {
+    input: ciphertext,
+    encoding: "utf-8"
+  });
+  if (result.error) {
+    console.error(`Decryption failed: ${result.error.message}. Is 'age' command installed and in your PATH?`);
+    return null;
+  }
+  if (result.status !== 0) {
+    console.error(`Decryption failed: ${result.stderr}`);
+    return null;
+  }
+  return result.stdout;
+}
+function generateAgeKey(outputPath) {
+  const result = spawnSync("age-keygen", ["-o", outputPath], {
+    encoding: "utf-8"
+  });
+  if (result.error) {
+    console.error(`Key generation failed: ${result.error.message}. Is 'age-keygen' command installed and in your PATH?`);
+    return false;
+  }
+  return result.status === 0;
+}
+function pushToSync(syncId, store, encryptRecipient) {
+  if (!isSyncInitialized()) {
+    console.error('Sync repository not initialized. Run "tm sync add" first.');
+    return false;
+  }
+  const projectFile = encryptRecipient ? getEncryptedProjectFilePath(syncId) : getProjectFilePath(syncId);
+  try {
+    const jsonData = JSON.stringify(store, null, 2);
+    if (encryptRecipient) {
+      const encrypted = encryptData(jsonData, encryptRecipient);
+      if (!encrypted)
+        return false;
+      writeFileSync3(projectFile, encrypted, "utf-8");
+    } else {
+      writeFileSync3(projectFile, jsonData, "utf-8");
+    }
+    return true;
+  } catch (e) {
+    console.error(`Failed to push to sync: ${e}`);
+    return false;
+  }
+}
+function tryAutoSync(syncConfig, store, encryptRecipient) {
+  if (!syncConfig?.enabled || !syncConfig.auto) {
+    return;
+  }
+  if (!isSyncInitialized()) {
+    return;
+  }
+  pushToSync(syncConfig.id, store, encryptRecipient);
+}
+function pullFromSync(syncId, encryptIdentityFile) {
+  if (!isSyncInitialized()) {
+    console.error('Sync repository not initialized. Run "tm sync add" first.');
+    return null;
+  }
+  const ageFile = getEncryptedProjectFilePath(syncId);
+  const jsonFile = getProjectFilePath(syncId);
+  try {
+    if (encryptIdentityFile && existsSync3(ageFile)) {
+      const ciphertext = readFileSync3(ageFile, "utf-8");
+      const decrypted = decryptData(ciphertext, encryptIdentityFile);
+      if (!decrypted)
+        return null;
+      return JSON.parse(decrypted);
+    }
+    if (existsSync3(jsonFile)) {
+      const data = readFileSync3(jsonFile, "utf-8");
+      return JSON.parse(data);
+    }
+    console.error(`Project "${syncId}" not found in sync repository.`);
+    return null;
+  } catch (e) {
+    console.error(`Failed to pull from sync: ${e}`);
+    return null;
+  }
+}
+function listSyncedProjects() {
+  if (!existsSync3(PROJECTS_DIR)) {
+    return [];
+  }
+  const files = readdirSync(PROJECTS_DIR);
+  return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
+}
+function runGitCommand(args) {
+  if (!isSyncInitialized()) {
+    console.error('Sync repository not initialized. Run "tm sync add" first.');
+    return 1;
+  }
+  const result = spawnSync("git", args, { cwd: SYNC_DIR, stdio: "inherit" });
+  return result.status ?? 1;
+}
+function normalizeRemoteUrl(url) {
+  let s = url.trim();
+  s = s.replace(/^https?:\/\//, "");
+  s = s.replace(/^git:\/\//, "");
+  s = s.replace(/^[^@]+@/, "");
+  s = s.replace(":", "/");
+  s = s.replace(/\.git$/, "");
+  s = s.replace(/\//g, "-");
+  s = s.replace(/[^a-zA-Z0-9._-]/g, "-");
+  s = s.replace(/^-+|-+$/g, "");
+  return s || "unknown";
+}
+function generateSyncId() {
+  const originResult = spawnSync("git", ["remote", "get-url", "origin"], {
+    cwd: process.cwd(),
+    encoding: "utf-8"
+  });
+  if (originResult.status === 0 && originResult.stdout) {
+    return normalizeRemoteUrl(originResult.stdout.trim());
+  }
+  const toplevelResult = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+    cwd: process.cwd(),
+    encoding: "utf-8"
+  });
+  if (toplevelResult.status === 0 && toplevelResult.stdout) {
+    return toplevelResult.stdout.trim().split("/").pop() || "unknown";
+  }
+  return process.cwd().split("/").pop() || "unknown";
+}
+
+// src/commands/sync.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+function mergeTasks(localTasks, remoteTasks) {
+  const merged = [...localTasks];
+  let idCollisions = 0;
+  let conflictsResolved = 0;
+  for (const remoteTask of remoteTasks) {
+    const sameTaskIndex = merged.findIndex((t) => t.id === remoteTask.id && t.created_at === remoteTask.created_at);
+    if (sameTaskIndex >= 0) {
+      const existing = merged[sameTaskIndex];
+      if (existing && new Date(remoteTask.updated_at) > new Date(existing.updated_at)) {
+        merged[sameTaskIndex] = remoteTask;
+        conflictsResolved++;
+      }
+    } else {
+      const hasIdCollision = merged.some((t) => t.id === remoteTask.id);
+      if (hasIdCollision) {
+        const newId = getNextId(merged);
+        merged.push({ ...remoteTask, id: newId });
+        idCollisions++;
+      } else {
+        merged.push(remoteTask);
+      }
+    }
+  }
+  return { tasks: merged, idCollisions, conflictsResolved };
+}
+function parseArgs(args) {
+  const subcommand = args[0] || "";
+  const options = {};
+  const positional = [];
+  let i = 1;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg?.startsWith("--")) {
+      const key = arg.slice(2);
+      const nextArg = args[i + 1];
+      if (nextArg && !nextArg.startsWith("--")) {
+        options[key] = nextArg;
+        i += 2;
+      } else {
+        options[key] = true;
+        i++;
+      }
+    } else {
+      positional.push(arg);
+      i++;
+    }
+  }
+  return { subcommand, options, positional };
+}
+function ensureInitialized() {
+  if (isSyncInitialized()) {
+    return true;
+  }
+  return initSyncRepo();
+}
+function handleAdd(options) {
+  if (!ensureInitialized()) {
+    console.error("Failed to initialize sync repository");
+    process.exit(1);
+  }
+  const existingConfig = loadSyncConfig();
+  if (existingConfig?.enabled) {
+    console.log(`Already added to sync with id: ${existingConfig.id}`);
+    return;
+  }
+  const syncId = (typeof options.id === "string" ? options.id : null) || generateSyncId();
+  const syncConfig = {
+    id: syncId,
+    enabled: true,
+    auto: false
+  };
+  saveSyncConfig(syncConfig);
+  console.log(`Added to sync with id: ${syncId}`);
+  if (options.save) {
+    const globalConfig = loadGlobalConfig();
+    const { recipient } = resolveEncryptSettings(syncConfig, globalConfig);
+    const store = loadStore();
+    if (pushToSync(syncId, store, recipient)) {
+      console.log("Saved to sync directory.");
+    }
+  }
+}
+function handleRemove() {
+  const existingConfig = loadSyncConfig();
+  if (!existingConfig?.enabled) {
+    console.log("Not currently synced.");
+    return;
+  }
+  const syncConfig = {
+    ...existingConfig,
+    enabled: false
+  };
+  saveSyncConfig(syncConfig);
+  console.log(`Removed from sync. (id was: ${existingConfig.id})`);
+}
+function resolveEncryptSettings(syncConfig, globalConfig) {
+  const enabled = syncConfig.encryptEnabled ?? globalConfig.defaultEncryptEnabled ?? false;
+  if (!enabled)
+    return { enabled: false, recipient: undefined, identityFile: undefined };
+  return {
+    enabled: true,
+    recipient: syncConfig.encryptRecipient ?? globalConfig.defaultEncryptRecipient,
+    identityFile: syncConfig.encryptIdentityFile ?? globalConfig.defaultEncryptIdentityFile
+  };
+}
+function handleSave() {
+  const syncConfig = loadSyncConfig();
+  if (!syncConfig?.enabled) {
+    console.error('Not synced. Run "tm sync add" first.');
+    process.exit(1);
+  }
+  const globalConfig = loadGlobalConfig();
+  const { recipient } = resolveEncryptSettings(syncConfig, globalConfig);
+  const store = loadStore();
+  if (pushToSync(syncConfig.id, store, recipient)) {
+    console.log(`Saved to sync directory. (id: ${syncConfig.id})`);
+  } else {
+    process.exit(1);
+  }
+}
+function handleLoad(options) {
+  const syncConfig = loadSyncConfig();
+  if (!syncConfig?.enabled) {
+    console.error('Not synced. Run "tm sync add" first.');
+    process.exit(1);
+  }
+  const globalConfig = loadGlobalConfig();
+  const { identityFile } = resolveEncryptSettings(syncConfig, globalConfig);
+  const remoteStore = pullFromSync(syncConfig.id, identityFile);
+  if (!remoteStore) {
+    process.exit(1);
+  }
+  const currentStore = loadStore();
+  const merge = options.merge === true;
+  if (merge) {
+    const result = mergeTasks(currentStore.tasks, remoteStore.tasks);
+    currentStore.tasks = result.tasks;
+    saveStore(currentStore);
+    let msg = `Merged from sync directory. (${remoteStore.tasks.length} tasks)`;
+    if (result.idCollisions > 0)
+      msg += ` ID collisions resolved: ${result.idCollisions}.`;
+    if (result.conflictsResolved > 0)
+      msg += ` Conflicts resolved: ${result.conflictsResolved}.`;
+    console.log(msg);
+  } else {
+    currentStore.tasks = remoteStore.tasks;
+    saveStore(currentStore);
+    console.log(`Loaded from sync directory. (${remoteStore.tasks.length} tasks)`);
+  }
+}
+function handleSetKey(positional, options) {
+  const isGlobal = options.global === true;
+  const isGenerate = options.generate === true;
+  const pathArg = positional[1] ?? null;
+  if (!isGenerate && !pathArg) {
+    console.error("Usage: tm sync set key <path> [--global]");
+    console.error("       tm sync set key --generate [--global]");
+    process.exit(1);
+  }
+  let identityFile;
+  if (isGenerate) {
+    identityFile = join4(getSyncDir(), "age.key");
+    if (!existsSync4(identityFile)) {
+      if (!generateAgeKey(identityFile)) {
+        console.error("Failed to generate age key.");
+        process.exit(1);
+      }
+      console.log(`Generated key file: ${identityFile}`);
+    } else {
+      console.log(`Using existing key file: ${identityFile}`);
+    }
+  } else {
+    identityFile = pathArg;
+    if (!existsSync4(identityFile)) {
+      console.error(`Key file not found: ${identityFile}`);
+      process.exit(1);
+    }
+  }
+  const pubkey = getPublicKeyFromIdentityFile(identityFile);
+  if (!pubkey) {
+    console.error(`Could not extract public key from: ${identityFile}`);
+    process.exit(1);
+  }
+  if (isGlobal) {
+    const globalConfig = loadGlobalConfig();
+    globalConfig.defaultEncryptIdentityFile = identityFile;
+    globalConfig.defaultEncryptRecipient = pubkey;
+    saveGlobalConfig(globalConfig);
+    console.log(`Global key file set: ${identityFile}`);
+    console.log(`Global recipient set to: ${pubkey}`);
+  } else {
+    const syncConfig = loadSyncConfig();
+    if (!syncConfig?.enabled) {
+      console.error('Not synced. Run "tm sync add" first.');
+      process.exit(1);
+    }
+    syncConfig.encryptIdentityFile = identityFile;
+    syncConfig.encryptRecipient = pubkey;
+    saveSyncConfig(syncConfig);
+    console.log(`Key file set: ${identityFile}`);
+    console.log(`Recipient set to: ${pubkey}`);
+  }
+}
+function handleSetEncrypt(positional, options) {
+  const isGlobal = options.global === true;
+  const value = positional[1];
+  if (value !== "on" && value !== "off") {
+    console.error("Usage: tm sync set encrypt <on|off> [--global]");
+    process.exit(1);
+  }
+  const enabled = value === "on";
+  if (isGlobal) {
+    const globalConfig = loadGlobalConfig();
+    globalConfig.defaultEncryptEnabled = enabled;
+    saveGlobalConfig(globalConfig);
+    console.log(`Global encryption ${enabled ? "enabled" : "disabled"}.`);
+  } else {
+    const syncConfig = loadSyncConfig();
+    if (!syncConfig?.enabled) {
+      console.error('Not synced. Run "tm sync add" first.');
+      process.exit(1);
+    }
+    syncConfig.encryptEnabled = enabled;
+    saveSyncConfig(syncConfig);
+    console.log(`Encryption ${enabled ? "enabled" : "disabled"}.`);
+  }
+}
+function handleSet(positional, options) {
+  const mode = positional[0];
+  if (mode === "key") {
+    handleSetKey(positional, options);
+    return;
+  }
+  if (mode === "encrypt") {
+    handleSetEncrypt(positional, options);
+    return;
+  }
+  if (mode !== "auto" && mode !== "manual") {
+    console.error("Usage: tm sync set <auto|manual|encrypt|key>");
+    process.exit(1);
+  }
+  const syncConfig = loadSyncConfig();
+  if (!syncConfig?.enabled) {
+    console.error('Not synced. Run "tm sync add" first.');
+    process.exit(1);
+  }
+  syncConfig.auto = mode === "auto";
+  saveSyncConfig(syncConfig);
+  console.log(`Sync mode set to: ${mode}`);
+}
+function handleStatus() {
+  const syncConfig = loadSyncConfig();
+  console.log("=== Sync Status ===");
+  console.log(`Sync Directory: ${getSyncDir()}`);
+  console.log(`Initialized: ${isSyncInitialized() ? "Yes" : "No"}`);
+  console.log("");
+  const globalConfig = loadGlobalConfig();
+  if (globalConfig.defaultEncryptEnabled !== undefined || globalConfig.defaultEncryptIdentityFile || globalConfig.defaultEncryptRecipient) {
+    console.log("=== Global Defaults ===");
+    if (globalConfig.defaultEncryptEnabled !== undefined) {
+      console.log(`Encrypt: ${globalConfig.defaultEncryptEnabled ? "on" : "off"}`);
+    }
+    if (globalConfig.defaultEncryptIdentityFile) {
+      console.log(`Key: ${globalConfig.defaultEncryptIdentityFile}`);
+    }
+    if (globalConfig.defaultEncryptRecipient) {
+      console.log(`Recipient: ${globalConfig.defaultEncryptRecipient}`);
+    }
+    console.log("");
+  }
+  if (syncConfig) {
+    console.log("=== Current Project ===");
+    console.log(`ID: ${syncConfig.id}`);
+    console.log(`Enabled: ${syncConfig.enabled ? "Yes" : "No"}`);
+    console.log(`Auto: ${syncConfig.auto ? "Yes" : "No"}`);
+    const { enabled: encryptEnabled, identityFile: identity, recipient } = resolveEncryptSettings(syncConfig, globalConfig);
+    console.log(`Encrypt: ${encryptEnabled ? "on" : "off"}${syncConfig.encryptEnabled === undefined ? " (global)" : ""}`);
+    if (encryptEnabled) {
+      if (identity)
+        console.log(`Key: ${identity}${syncConfig.encryptIdentityFile === undefined ? " (global)" : ""}`);
+      if (recipient)
+        console.log(`Recipient: ${recipient}${syncConfig.encryptRecipient === undefined ? " (global)" : ""}`);
+    }
+  } else {
+    console.log("Current project is not synced.");
+  }
+  console.log("");
+  const projects = listSyncedProjects();
+  if (projects.length > 0) {
+    console.log("=== Synced Projects ===");
+    for (const p of projects) {
+      console.log(`  - ${p}`);
+    }
+  }
+}
+function checkGhAuth() {
+  const ghCheck = spawnSync2("gh", ["auth", "status"], { encoding: "utf-8" });
+  if (ghCheck.error || ghCheck.status !== 0) {
+    console.error('gh command is not available or not authenticated. Run "gh auth login" first.');
+    process.exit(1);
+  }
+}
+function handleUpload(options) {
+  const syncConfig = loadSyncConfig();
+  if (!syncConfig?.enabled) {
+    console.error('Not synced. Run "tm sync add" first.');
+    process.exit(1);
+  }
+  const globalConfig = loadGlobalConfig();
+  const { recipient } = resolveEncryptSettings(syncConfig, globalConfig);
+  const store = loadStore();
+  if (!pushToSync(syncConfig.id, store, recipient)) {
+    process.exit(1);
+  }
+  console.log(`Saved. (id: ${syncConfig.id})`);
+  runGitCommand(["add", "."]);
+  const now = new Date;
+  const pad = (n) => String(n).padStart(2, "0");
+  const defaultMessage = `sync: ${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}`;
+  const message = typeof options.message === "string" ? options.message : defaultMessage;
+  const commitResult = spawnSync2("git", ["commit", "-m", message], {
+    cwd: getSyncDir(),
+    encoding: "utf-8",
+    stdio: "pipe"
+  });
+  if (commitResult.status !== 0) {
+    if (commitResult.stdout.includes("nothing to commit")) {
+      console.log("Nothing to commit.");
+    } else {
+      console.error("Failed to commit.");
+      console.error(commitResult.stderr);
+      process.exit(1);
+    }
+  } else {
+    console.log(`Committed: ${message}`);
+  }
+  const pushResult = spawnSync2("git", ["push", "--set-upstream", "origin", "HEAD"], {
+    cwd: getSyncDir(),
+    stdio: "inherit"
+  });
+  if (pushResult.status !== 0) {
+    console.error("Failed to push.");
+    process.exit(1);
+  }
+}
+function handleRepoCreate(options) {
+  checkGhAuth();
+  if (!ensureInitialized()) {
+    console.error("Failed to initialize sync repository");
+    process.exit(1);
+  }
+  const isPublic = options.public === true;
+  const repoName = typeof options.name === "string" ? options.name : "sync-task-memory";
+  const visibility = isPublic ? "--public" : "--private";
+  console.log(`Creating ${isPublic ? "public" : "private"} repository: ${repoName}`);
+  const createResult = spawnSync2("gh", ["repo", "create", repoName, visibility], {
+    encoding: "utf-8",
+    stdio: "pipe"
+  });
+  if (createResult.status !== 0) {
+    console.error("Failed to create repository.");
+    console.error(createResult.stderr);
+    process.exit(1);
+  }
+  const repoUrl = createResult.stdout.trim();
+  console.log(`Repository created: ${repoUrl}`);
+  spawnSync2("git", ["remote", "remove", "origin"], { cwd: getSyncDir(), encoding: "utf-8" });
+  spawnSync2("git", ["remote", "add", "origin", repoUrl], { cwd: getSyncDir(), stdio: "inherit" });
+  console.log(`Remote set. Use "tm git push" to push your data.`);
+}
+function handleRepoSet(positional) {
+  const url = positional[1];
+  if (!url) {
+    console.error("Usage: tm sync repo set <url>");
+    process.exit(1);
+  }
+  if (!ensureInitialized()) {
+    console.error("Failed to initialize sync repository");
+    process.exit(1);
+  }
+  spawnSync2("git", ["remote", "remove", "origin"], { cwd: getSyncDir(), encoding: "utf-8" });
+  const addResult = spawnSync2("git", ["remote", "add", "origin", url], {
+    cwd: getSyncDir(),
+    stdio: "inherit"
+  });
+  if (addResult.status !== 0) {
+    console.error("Failed to set remote.");
+    process.exit(1);
+  }
+  console.log(`Remote set: ${url}`);
+}
+function handleRepoShow() {
+  const result = spawnSync2("git", ["remote", "-v"], {
+    cwd: getSyncDir(),
+    encoding: "utf-8"
+  });
+  if (result.status !== 0 || !result.stdout.trim()) {
+    console.log('No remote configured. Use "tm sync repo create" or "tm sync repo set <url>".');
+    return;
+  }
+  console.log(result.stdout.trim());
+}
+function handleRepo(positional, options) {
+  const subcommand = positional[0];
+  switch (subcommand) {
+    case "create":
+      handleRepoCreate(options);
+      break;
+    case "set":
+      handleRepoSet(positional);
+      break;
+    case "show":
+      handleRepoShow();
+      break;
+    default:
+      console.error("Usage: tm sync repo <create|set|show>");
+      process.exit(1);
+  }
+}
+function handleList2() {
+  const projects = listSyncedProjects();
+  if (projects.length === 0) {
+    console.log("No projects synced.");
+    return;
+  }
+  console.log("Synced projects:");
+  for (const p of projects) {
+    console.log(`  - ${p}`);
+  }
+}
+function showHelp() {
+  console.log(`
+Usage: tm sync <subcommand> [options]
+
+Subcommands:
+  add [--id <name>] [--save]
+                          Add current project to sync
+  remove                  Remove current project from sync
+  save                    Save tasks to sync directory
+  upload [--message <msg>]
+                          Save, git commit, and git push
+  load [--merge]          Load tasks from sync directory
+  set <auto|manual>       Set sync mode
+  set encrypt <on|off>    Enable/disable encryption for current project
+  set encrypt <on|off> --global
+                          Enable/disable encryption globally (used as fallback)
+  set key <path>     Set key file (private key); recipient auto-extracted
+  set key --generate Generate a new key file; recipient auto-extracted
+  set key [--generate] --global
+                          Apply setting globally (used as fallback)
+  repo create [--name <name>] [--public]
+                          Create GitHub repository and set as remote (requires gh)
+                          Default name: sync-task-memory
+  repo set <url>          Set existing repository as remote
+  repo show               Show current remote
+  status                  Show sync status
+  list                    List synced projects
+
+Examples:
+  tm sync add --id my-project --save
+  tm sync set key --generate --global  # age鍵を生成しグローバルに設定
+  tm sync set key ~/.age.key --global  # 既存の鍵をグローバルに設定
+  tm sync set encrypt on --global           # 暗号化をグローバルでデフォルト有効化
+  tm sync set encrypt off                   # 現プロジェクトだけ暗号化を無効化
+  tm sync repo create                  # privateリポジトリを作成
+  tm sync repo create --public         # publicリポジトリを作成
+  tm sync repo create --name my-tasks  # リポジトリ名を指定
+  tm sync save
+  tm sync load --merge
+  tm sync set auto
+    `);
+}
+function syncCommand(args) {
+  const { subcommand, options, positional } = parseArgs(args);
+  switch (subcommand) {
+    case "add":
+      handleAdd(options);
+      break;
+    case "remove":
+    case "rm":
+      handleRemove();
+      break;
+    case "save":
+      handleSave();
+      break;
+    case "upload":
+      handleUpload(options);
+      break;
+    case "load":
+      handleLoad(options);
+      break;
+    case "set":
+      handleSet(positional, options);
+      break;
+    case "repo":
+      handleRepo(positional, options);
+      break;
+    case "status":
+      handleStatus();
+      break;
+    case "list":
+    case "ls":
+      handleList2();
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      showHelp();
+      break;
+    default:
+      if (!subcommand) {
+        showHelp();
+      } else {
+        console.error(`Unknown subcommand: ${subcommand}`);
+        showHelp();
+        process.exit(1);
+      }
+  }
+}
+
+// src/commands/git.ts
+function gitCommand(args) {
+  if (!isSyncInitialized()) {
+    console.error('Sync repository not initialized. Run "tm sync add" first.');
+    process.exit(1);
+  }
+  if (args.length === 0) {
+    console.log(`Git repository at: ${getSyncDir()}`);
+    console.log("Usage: tm git <git-command> [args]");
+    console.log("");
+    console.log("Examples:");
+    console.log("  tm git status");
+    console.log("  tm git remote add origin git@github.com:user/task-memory.git");
+    console.log("  tm git push");
+    console.log("  tm git pull");
+    return;
+  }
+  const exitCode = runGitCommand(args);
+  process.exit(exitCode);
+}
+
+// docs/usage/index.md
+var usage_default = `# ユーザーガイド
+
+\`task-memory\` (tm) は、AIエージェントや開発者がタスクの状態を管理し、コンテキストの喪失を防ぐためのツールです。
+
+このドキュメントは \`tm docs\` コマンドでいつでも参照できます。
+
+## インストール方法
+
+### ローカルインストール
+
+このリポジトリをクローンし、ローカルコマンドとしてリンクします。
+
+\`\`\`bash
+git clone <repository-url> task-memory
+cd task-memory
+bun install
+bun link
+\`\`\`
+
+これで \`tm\` コマンドがグローバルに使用可能になります（Bunのbinパスが通っている必要があります）。
+
+または、エイリアスを設定して使用することも可能です。
+
+\`\`\`bash
+alias tm="bun run /path/to/task-memory/src/index.ts"
+\`\`\`
+
+## 基本的な使い方
+
+### 1. タスクの作成 (\`tm new\`)
+
+新しいタスクを開始する際に使用します。
+
+\`\`\`bash
+tm new "認証機能のリファクタリング"
+# 出力: TASK-1 認証機能のリファクタリング
+\`\`\`
+
+#### 進行順序の設定
+
+タスクに進行順序（order）を設定することで、作業の優先順位を階層的に管理できます。
+
+**基本的な使い方:**
+\`\`\`bash
+# 順番に並べる
+tm new "Task 1" --order 1
+tm new "Task 2" --order 2
+tm new "Task 3" --order 3
+\`\`\`
+
+**階層的な順序:**
+\`\`\`bash
+# 親タスク
+tm new "Database Migration" --order 1
+
+# 子タスク（1の下位タスク）
+tm new "Backup current DB" --order 1-1
+tm new "Run migration script" --order 1-2
+tm new "Verify data integrity" --order 1-3
+
+# 孫タスク（1-2の下位タスク）
+tm new "Test migration locally" --order 1-2-1
+tm new "Deploy to staging" --order 1-2-2
+
+# 別の親タスク
+tm new "Documentation" --order 2
+\`\`\`
+
+**小数での挿入:**
+\`\`\`bash
+# すでに 1, 2 がある場合、間に挿入
+tm new "Insert between 1 and 2" --order 1.5
+# 保存時に自動的に正規化されて 1, 2, 3 になります
+\`\`\`
+
+**order の特徴:**
+- \`todo\`, \`wip\` ステータスのみ order を保持
+- \`done\`, \`closed\`, \`pending\`, \`long\` に変更すると order は自動的に解除
+- 欠番は自動的に詰められる（1, 3, 5 → 1, 2, 3）
+- 孫タスクがある場合、その親番号は確保される
+- 既存の order と同じ値を設定すると、新しいタスクが優先され、既存タスクは後ろにシフトされる
+
+**既存 order への挿入（インサートセマンティクス）:**
+\`\`\`bash
+# order=1 が A, B, C に割り当てられている場合に新タスクへ order=1 を設定すると
+# → 新タスク=1, A=2, B=3, C=4 と全体がシフトする
+tm update <新タスクID> --order 1
+\`\`\`
+
+### 2. タスク一覧の表示 (\`tm list\`)
+
+現在進行中（\`todo\`, \`wip\`）のタスクを表示します。
+
+\`\`\`bash
+tm list
+# または短縮形
+tm ls
+tm l
+# 出力: 1: 認証機能のリファクタリング [todo]
+\`\`\`
+
+#### フィルタリングオプション
+
+タスク一覧は様々な条件でフィルタリングできます。
+
+**ステータスによるフィルタリング:**
+\`\`\`bash
+# すべてのタスク（done/closed含む）を表示
+tm list --status-all
+tm ls -a
+
+# オープンなタスク（todo, wip, pending, long）を表示
+tm list --open
+
+# 特定のステータスのタスクのみ表示
+tm list --status pending
+tm ls -s wip
+tm ls -s done
+\`\`\`
+
+**優先度によるフィルタリング:**
+\`\`\`bash
+tm list --priority high
+tm list --priority medium
+\`\`\`
+
+**バージョンによるフィルタリング:**
+\`\`\`bash
+# 特定のバージョン
+tm list --version 1.0.0
+
+# TBD（未リリース）のタスク
+tm list --tbd
+
+# リリース済みのタスク（version が tbd 以外）
+tm list --released
+\`\`\`
+
+**表示件数の制限:**
+\`\`\`bash
+# 最初の5件のみ表示
+tm list --head 5
+
+# 最後の10件のみ表示
+tm list --tail 10
+
+# デフォルト値（10件）で制限
+tm list --head
+tm list --tail
+\`\`\`
+
+**組み合わせ:**
+\`\`\`bash
+# リリース済みタスクの最初の3件
+tm list --released --head 3
+
+# 高優先度のpendingタスク
+tm list --priority high --status pending
+\`\`\`
+
+#### ソート順の指定
+
+デフォルトでは進行順序（order）でソートされます。
+
+\`\`\`bash
+# 進行順序でソート（デフォルト）
+tm list --sort order
+# order が未設定のタスクは後ろに表示されます
+# 1 < 1-1 < 1-2 < 2 < 2-1 の順
+
+# タスクID順
+tm list --sort id
+
+# 作成日時順
+tm list --sort created
+\`\`\`
+
+### 3. タスクの更新 (\`tm update\`)
+
+タスクの状態を更新したり、作業ログ（body）を追記したりします。
+複数のタスクを一度に更新することも可能です。
+
+**ステータスの変更:**
+
+\`\`\`bash
+tm update 1 --status wip
+\`\`\`
+
+**作業ログの追記:**
+
+\`\`\`bash
+tm update 1 --body "JWTの実装を開始"
+\`\`\`
+
+**関連ファイルの追加（AIエージェント向け）:**
+
+\`\`\`bash
+tm update 1 --add-file src/auth.ts
+\`\`\`
+
+**進行順序の更新:**
+
+\`\`\`bash
+# order を設定
+tm update 1 --order 1-2
+
+# order を解除
+tm update 1 --order null
+\`\`\`
+
+**複数タスクの同時更新（コンテキストスイッチ）:**
+
+\`\`\`bash
+tm update 1 --status done 2 --status wip --body "バグ調査中"
+# タスク1を完了にし、タスク2をWIPにしてログを追記
+\`\`\`
+
+### 4. タスク詳細の確認 (\`tm get\`)
+
+タスクの詳細情報（JSON形式）を取得します。AIエージェントがコンテキストを復元するのに役立ちます。
+
+\`\`\`bash
+tm get 1
+\`\`\`
+
+履歴をすべて表示するには \`--history\` または \`--all\` オプションを使用します。
+
+\`\`\`bash
+tm get 1 --history
+\`\`\`
+
+### 5. タスクの完了 (\`tm finish\`)
+
+タスクを完了状態（\`done\`）にします。
+
+\`\`\`bash
+tm finish 1
+\`\`\`
+
+## データの保存場所
+
+以下の優先順位でデータの保存先が決定されます。
+
+| 優先度 | 条件 | 保存先 |
+|--------|------|--------|
+| 1 | 環境変数 \`TASK_MEMORY_PATH\` が設定されている | 環境変数で指定したパス |
+| 2 | \`.git\` ディレクトリが存在し、かつ \`.git/task-memory.json\` が存在する | \`.git/task-memory.json\` |
+| 3 | \`.git\`（ファイル・ディレクトリ問わず）と同じ階層に \`task-memory.json\` が存在する | \`<プロジェクトルート>/task-memory.json\` |
+| 4 | \`.git\` と同じ階層に \`.task-memory.json\` が存在する | \`<プロジェクトルート>/.task-memory.json\` |
+| 5 | \`.git\` が存在するが保存ファイルがない（新規） | \`.git/task-memory.json\`（\`.git\` がディレクトリの場合）または \`<プロジェクトルート>/task-memory.json\` |
+| 6 | \`.git\` が存在しない | \`~/.task-memory.json\` |
+
+### git worktree での利用
+
+\`git worktree\` 使用時は \`.git\` がファイルになりますが、そのファイルと同じ階層の \`task-memory.json\` または \`.task-memory.json\` が自動的に参照されます。これにより、worktree ごとに独立したタスク管理が可能です。
+
+## 同期機能 (\`tm sync\`)
+
+タスクデータを \`~/.local/task-memory/\` 経由で複数環境間で同期します。
+
+### セットアップ
+
+\`\`\`bash
+# 同期を有効化（sync ID を自動生成）
+tm sync add
+
+# 同期 ID を指定（複数マシン間で同じIDを使う場合）
+tm sync add --id my-project-sync
+\`\`\`
+
+### 基本操作
+
+\`\`\`bash
+# タスクを同期ディレクトリに保存
+tm sync save
+
+# 同期ディレクトリからタスクを読み込み（上書き）
+tm sync load
+
+# 読み込み時にローカルとマージ
+tm sync load --merge
+
+# 保存・コミット・プッシュを一括実行
+tm sync upload
+
+# コミットメッセージを指定
+tm sync upload --message "作業完了"
+
+# 同期状態を確認
+tm sync status
+
+# 同期を無効化
+tm sync remove
+\`\`\`
+
+### GitHubリポジトリとの連携
+
+\`\`\`bash
+# GitHubにprivateリポジトリを作成してremoteに設定（gh コマンド必要）
+tm sync repo create
+
+# リポジトリ名を指定
+tm sync repo create --name my-sync-repo
+
+# publicリポジトリとして作成
+tm sync repo create --public
+
+# 既存のリポジトリをremoteに設定
+tm sync repo set git@github.com:user/repo.git
+
+# 現在のremoteを確認
+tm sync repo show
+\`\`\`
+
+リポジトリ設定後は \`tm git push\` / \`tm git pull\` で同期できます。
+
+### マージ動作
+
+\`--merge\` オプションでは以下のルールでマージされます：
+
+- **同一タスク**（ID と作成日時が一致）: \`updated_at\` が新しい方を優先
+- **ID 衝突**（同じ ID だが別のタスク）: リモートのタスクに新しい ID を割り当てて追加
+- **新規タスク**: そのまま追加
+
+### 暗号化
+
+[age](https://age-encryption.org/) による非対称暗号化をサポートします。
+
+\`\`\`bash
+# identity ファイルを生成してグローバルに設定（公開鍵も自動設定）
+tm sync set key --generate --global
+
+# 既存の identity ファイルをグローバルに設定
+tm sync set key ~/.age.key --global
+
+# 暗号化を有効化（グローバル）
+tm sync set encrypt on --global
+
+# 特定プロジェクトのみ暗号化を無効化
+tm sync set encrypt off
+\`\`\`
+
+- 暗号化時: \`identity\` ファイルから公開鍵を抽出して暗号化（push 側）
+- 復号時: \`identity\` ファイルの秘密鍵で復号（pull 側）
+- 同期ファイルは \`.json.age\` として保存される
+
+**注意**: identity ファイルを紛失するとデータを復元できません。安全な場所にバックアップしてください。
+`;
+
+// src/index.ts
+setAfterSaveCallback((store) => {
+  tryAutoSync(store.sync, store);
+});
+var args = process.argv.slice(2);
+var command = args[0];
+var commandArgs = args.slice(1);
+switch (command) {
+  case "new":
+    newCommand(commandArgs);
+    break;
+  case "list":
+  case "ls":
+  case "l":
+    listCommand(commandArgs);
+    break;
+  case "get":
+  case "g":
+    getCommand(commandArgs);
+    break;
+  case "finish":
+  case "fin":
+  case "f":
+    finishCommand(commandArgs);
+    break;
+  case "update":
+  case "up":
+  case "u":
+    updateCommand(commandArgs);
+    break;
+  case "env":
+    envCommand(commandArgs);
+    break;
+  case "review":
+  case "rev":
+  case "tmr":
+    reviewCommand(commandArgs);
+    break;
+  case "release":
+    releaseCommand(commandArgs);
+    break;
+  case "close":
+    closeCommand(commandArgs);
+    break;
+  case "sync":
+    syncCommand(commandArgs);
+    break;
+  case "git":
+    gitCommand(commandArgs);
+    break;
+  case "docs":
+    console.log(usage_default);
+    break;
+  case "help":
+  case "--help":
+  case "-h":
+    console.log(`
+Usage: tm <command> [args]
+
+Commands:
+  new <summary> [options]
+    Create a new task.
+    Options:
+      --status, -s <status>    Set initial status (todo, wip, done, pending, long, closed)
+      --priority, -p <value>   Set priority
+      --goal, -g <text>        Set completion goal
+      --body, -b <text>        Add initial body text
+      --add-file, -a <path>    Add editable file
+      --read-file, -r <path>   Add read-only file
+
+  list (ls, l) [options]
+    List active tasks (todo, wip).
+    Options:
+      --status-all, -a         Show all tasks (including done/closed)
+      --open                   Show all open tasks (todo, wip, pending, long)
+      --priority <p>           Filter by priority
+      --status, -s <status>    Filter by status
+      --version <v>            Filter by version
+      --tbd                    Filter by version 'tbd' (includes closed/done)
+      --released               Filter by released tasks (non-tbd version)
+      --head [N]               Show first N tasks (default: 10)
+      --tail [N]               Show last N tasks (default: 10)
+
+  get (g) <id...> [options]
+    Get task details (JSON).
+    Options:
+      --all, -a, --history, -h     Show full history of bodies
+
+  finish (fin, f) <id...>
+    Mark task(s) as done.
+
+  update (up, u) <id...> [options]
+    Update task(s). Supports context switching.
+    Options:
+      --status, -s <status>    Update status (todo, wip, done, pending, long, closed)
+      --priority, -p <value>   Update priority
+      --goal, -g <text>        Update completion goal
+      --body, -b <text>        Append body text
+      --add-file, -a <path>    Add editable file
+      --rm-file, -d <path>     Remove editable file
+      --read-file, -r <path>   Add read-only file
+
+  env
+    Show the current task data file path.
+
+  review (rev, tmr) <subcommand> [args]
+    Manage reviews.
+    Subcommands: new, list, get, update, return, accept, reject
+
+  release <id...> --version <v>
+    Set version for task(s).
+
+  close <id...> [--body <text>]
+    Close task(s). Alias for update --status closed.
+
+  sync <subcommand> [options]
+    Sync tasks to ~/.local/task-memory/ repository.
+    Subcommands: add, remove, push, pull, set, status, list
+
+  git <git-command> [args]
+    Run git commands in ~/.local/task-memory/ repository.
+
+  docs
+    Show usage documentation.
+
+Examples:
+  tm new "Refactor auth" --status wip --body "Starting now" --priority high
+  tm update 1 --status done 2 --status wip --body "Fixing bug"
+  tm get 1 --history
+    `);
+    break;
+  default:
+    if (!command) {
+      console.log(`
+Usage: tm <command> [args]
+
+Run 'tm help' for detailed usage and examples.
+        `);
+    } else {
+      console.error(`Error: Unknown command '${command}'. Run 'tm help' for usage.`);
+      process.exit(1);
+    }
+}