pybao-cli 1.4.49 → 1.4.51

package/dist/{chunk-MCP52ZSD.js → chunk-L2FQX7IL.js}

@@ -4,18 +4,21 @@ import {
   getSessionState,
   setSessionState
 } from "./chunk-ERMQRV55.js";
+import {
+  getPybAgentSessionId
+} from "./chunk-B6IMQJZM.js";
 import {
   getCurrentProjectConfig,
   getGlobalConfig
-} from "./chunk-2U747SA5.js";
+} from "./chunk-LEQNJ73H.js";
 import {
   debug
-} from "./chunk-XHGUMYRL.js";
+} from "./chunk-6MFZG46W.js";
 import {
   getCwd,
   logError,
   resolveXdgDataPath
-} from "./chunk-UUGWQSET.js";
+} from "./chunk-HJDETBB6.js";
 
 // src/utils/agent/storage.ts
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
@@ -81,16 +84,153 @@ function generateAgentId() {
 // src/utils/session/taskStore.ts
 import {
   existsSync as existsSync2,
+  closeSync,
   mkdirSync as mkdirSync2,
+  openSync,
   readFileSync as readFileSync2,
   readdirSync,
+  renameSync,
   rmSync,
   writeFileSync as writeFileSync2
 } from "fs";
 import { join as join2 } from "path";
 import { homedir } from "os";
-import { createHash } from "crypto";
-var DEFAULT_LOCK_TTL_MS = 6e4;
+import { randomUUID as randomUUID2 } from "crypto";
+import { AsyncLocalStorage } from "async_hooks";
+
+// src/utils/session/taskLockNative.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var getLinuxVariant = (report) => {
+  const glibc = report?.getReport?.()?.header?.glibcVersionRuntime;
+  return glibc ? "gnu" : "musl";
+};
+var resolveNativeLockPackage = (options) => {
+  const platform = options?.platform ?? process.platform;
+  const arch = options?.arch ?? process.arch;
+  const report = options?.report ?? process.report;
+  if (platform === "win32" && arch === "x64") {
+    return "@pyb/lock-win32-x64-msvc";
+  }
+  if (platform === "win32" && arch === "arm64") {
+    return "@pyb/lock-win32-arm64-msvc";
+  }
+  if (platform === "darwin" && arch === "x64") {
+    return "@pyb/lock-darwin-x64";
+  }
+  if (platform === "darwin" && arch === "arm64") {
+    return "@pyb/lock-darwin-arm64";
+  }
+  if (platform === "linux" && arch === "x64") {
+    const variant = getLinuxVariant(report);
+    return variant === "musl" ? "@pyb/lock-linux-x64-musl" : "@pyb/lock-linux-x64-gnu";
+  }
+  if (platform === "linux" && arch === "arm64") {
+    return "@pyb/lock-linux-arm64-gnu";
+  }
+  if (platform === "linux" && arch === "arm") {
+    return "@pyb/lock-linux-armv7-gnueabihf";
+  }
+  return null;
+};
+var cachedLock;
+var loadNativeTaskLock = () => {
+  const globalLock = globalThis.__PYB_NATIVE_TASK_LOCK__;
+  if (globalLock) {
+    cachedLock = globalLock;
+    return cachedLock;
+  }
+  if (cachedLock !== void 0) return cachedLock;
+  const envPath = process.env.PYB_NATIVE_LOCK_NODE_PATH;
+  if (envPath) {
+    try {
+      const mod = require2(envPath);
+      const candidate = mod?.default ?? mod;
+      if (candidate && typeof candidate.lockExclusive === "function" && typeof candidate.tryLockExclusive === "function" && typeof candidate.unlock === "function") {
+        cachedLock = candidate;
+        return cachedLock;
+      }
+    } catch {
+    }
+  }
+  const packageName = resolveNativeLockPackage();
+  if (!packageName) {
+    cachedLock = null;
+    return null;
+  }
+  try {
+    const mod = require2(packageName);
+    const candidate = mod?.default ?? mod;
+    if (candidate && typeof candidate.lockExclusive === "function" && typeof candidate.tryLockExclusive === "function" && typeof candidate.unlock === "function") {
+      cachedLock = candidate;
+      return cachedLock;
+    }
+  } catch {
+  }
+  cachedLock = null;
+  return null;
+};
+
+// src/utils/session/taskStore.ts
+var taskListIdStorage = new AsyncLocalStorage();
+var taskListEnvStorage = new AsyncLocalStorage();
+var nativeLock = null;
+var nativeLockResolved = false;
+function getNativeLock() {
+  const globalLock = globalThis.__PYB_NATIVE_TASK_LOCK__;
+  if (globalLock) {
+    nativeLock = globalLock;
+    nativeLockResolved = true;
+    return nativeLock;
+  }
+  if (nativeLockResolved) return nativeLock;
+  nativeLockResolved = true;
+  nativeLock = loadNativeTaskLock();
+  return nativeLock;
+}
+function generateTaskListId() {
+  return randomUUID2();
+}
+function runWithTaskListId(listId, handler) {
+  return taskListIdStorage.run(listId, () => {
+    const result = handler();
+    const asyncIterator = result && typeof result[Symbol.asyncIterator] === "function" ? result : null;
+    if (!asyncIterator) return result;
+    return {
+      [Symbol.asyncIterator]() {
+        const iterator = asyncIterator[Symbol.asyncIterator]();
+        return {
+          next: (value) => taskListIdStorage.run(listId, () => iterator.next(value)),
+          return: iterator.return ? (value) => taskListIdStorage.run(listId, () => iterator.return(value)) : void 0,
+          throw: iterator.throw ? (err) => taskListIdStorage.run(listId, () => iterator.throw(err)) : void 0
+        };
+      }
+    };
+  });
+}
+function runWithTaskListEnv(env, handler) {
+  return taskListEnvStorage.run(env, () => {
+    const result = handler();
+    const asyncIterator = result && typeof result[Symbol.asyncIterator] === "function" ? result : null;
+    if (!asyncIterator) return result;
+    return {
+      [Symbol.asyncIterator]() {
+        const iterator = asyncIterator[Symbol.asyncIterator]();
+        return {
+          next: (value) => taskListEnvStorage.run(env, () => iterator.next(value)),
+          return: iterator.return ? (value) => taskListEnvStorage.run(env, () => iterator.return(value)) : void 0,
+          throw: iterator.throw ? (err) => taskListEnvStorage.run(env, () => iterator.throw(err)) : void 0
+        };
+      }
+    };
+  });
+}
+var taskListLocks = /* @__PURE__ */ new Map();
+var taskLockWaitBuffer = new Int32Array(new SharedArrayBuffer(4));
+var DEFAULT_LOCK_TIMEOUT_MS = Number(
+  process.env.PYB_TASK_LOCK_TIMEOUT_MS ?? 5e3
+);
+var DEFAULT_LOCK_RETRY_MS = Number(process.env.PYB_TASK_LOCK_RETRY_MS ?? 50);
 var TaskStoreLockError = class extends Error {
   code = "TASK_STORE_LOCKED";
   constructor(message) {
@@ -114,7 +254,7 @@ var TaskStoreConflictError = class extends Error {
   }
 };
 function getDefaultTaskListId(cwd) {
-  return createHash("sha256").update(cwd).digest("hex").slice(0, 12);
+  return getPybAgentSessionId();
 }
 function resolveGlobalTaskRootDir() {
   const override = process.env.PYB_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR;
@@ -133,12 +273,13 @@ function findBaseDirWithList(listId, candidates) {
   return null;
 }
 function getTaskListContext(options) {
-  const env = options?.env ?? process.env;
+  const env = options?.env ?? taskListEnvStorage.getStore() ?? process.env;
   const globalConfig = options?.globalConfig ?? getGlobalConfig();
   const projectConfig = options?.projectConfig ?? getCurrentProjectConfig();
   const cwd = options?.cwd ?? getCwd();
   const defaultId = getDefaultTaskListId(cwd);
   const inputListId = options?.listId?.trim();
+  const contextListId = taskListIdStorage.getStore()?.trim();
   const envId = env.PYB_TASK_LIST_ID?.trim() || env.CLAUDE_CODE_TASK_LIST_ID?.trim();
   const globalId = globalConfig?.taskListId?.trim();
   const projectId = projectConfig?.taskListId?.trim();
@@ -151,6 +292,9 @@ function getTaskListContext(options) {
     }
     return { listId: inputListId, scope: "project", source: "input" };
   }
+  if (contextListId) {
+    return { listId: contextListId, scope: "project", source: "context" };
+  }
   if (envId) return { listId: envId, scope: "global", source: "env" };
   if (globalId) return { listId: globalId, scope: "global", source: "global" };
   if (projectId) return { listId: projectId, scope: "project", source: "project" };
@@ -182,24 +326,92 @@ function resolveTaskBaseDir(context, cwd) {
   const candidates = [...globalCandidates, resolveXdgDataPath("tasks")];
   return findBaseDirWithList(context.listId, candidates) ?? defaultBaseDir;
 }
-function getTaskListPaths(listId) {
-  const context = getTaskListContext({ listId });
-  const cwd = getCwd();
-  const baseDir = resolveTaskBaseDir(context, cwd);
-  const listDir = join2(baseDir, context.listId);
+function buildTaskListPaths(baseDir, listId) {
+  const listDir = join2(baseDir, listId);
   return {
-    listId: context.listId,
+    listId,
     baseDir,
     listDir,
     tasksDir: listDir,
-    indexPath: join2(listDir, "index.json"),
-    metaPath: join2(listDir, "meta.json"),
     lockPath: join2(listDir, ".lock"),
-    eventsPath: join2(listDir, "events.jsonl")
+    highwatermarkPath: join2(listDir, ".highwatermark")
   };
 }
+function getTaskListPaths(listId) {
+  const context = getTaskListContext({ listId });
+  const cwd = getCwd();
+  const baseDir = resolveTaskBaseDir(context, cwd);
+  return buildTaskListPaths(baseDir, context.listId);
+}
+function initTaskListLockFile(options) {
+  const paths = getTaskListPaths(options?.listId);
+  ensureTaskListDirs(paths);
+}
+function sortReadPaths(paths) {
+  const priority = { pyb: 0, claude: 1, other: 2 };
+  return [...paths].sort((a, b) => priority[a.source] - priority[b.source]);
+}
+function resolveSourceForBaseDir(baseDir) {
+  if (baseDir.includes(`${join2(".pyb", "tasks")}`)) return "pyb";
+  if (baseDir.includes(`${join2(".claude", "tasks")}`)) return "claude";
+  if (baseDir.includes(`${join2(".pyb")}`)) return "pyb";
+  if (baseDir.includes(`${join2(".claude")}`)) return "claude";
+  return "other";
+}
+function getTaskListReadPaths(listId) {
+  const context = getTaskListContext({ listId });
+  const cwd = getCwd();
+  const projectPyb = join2(cwd, ".pyb", "tasks");
+  const projectClaude = join2(cwd, ".claude", "tasks");
+  if (context.scope === "project") {
+    const existing2 = [];
+    if (existsSync2(join2(projectPyb, context.listId))) {
+      existing2.push({
+        ...buildTaskListPaths(projectPyb, context.listId),
+        source: "pyb"
+      });
+    }
+    if (existsSync2(join2(projectClaude, context.listId))) {
+      existing2.push({
+        ...buildTaskListPaths(projectClaude, context.listId),
+        source: "claude"
+      });
+    }
+    if (existing2.length > 0) return sortReadPaths(existing2);
+  }
+  const override = process.env.PYB_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR;
+  const globalCandidates = override ? [
+    {
+      baseDir: join2(override, "tasks"),
+      source: resolveSourceForBaseDir(join2(override, "tasks"))
+    }
+  ] : [
+    { baseDir: join2(homedir(), ".pyb", "tasks"), source: "pyb" },
+    { baseDir: join2(homedir(), ".claude", "tasks"), source: "claude" }
+  ];
+  const candidates = [
+    ...globalCandidates,
+    { baseDir: resolveXdgDataPath("tasks"), source: "other" }
+  ];
+  const existing = candidates.filter((candidate) => existsSync2(join2(candidate.baseDir, context.listId))).map((candidate) => ({
+    ...buildTaskListPaths(candidate.baseDir, context.listId),
+    source: candidate.source
+  }));
+  if (existing.length > 0) return sortReadPaths(existing);
+  const baseDir = resolveTaskBaseDir(context, cwd);
+  return [
+    {
+      ...buildTaskListPaths(baseDir, context.listId),
+      source: resolveSourceForBaseDir(baseDir)
+    }
+  ];
+}
 function ensureTaskListDirs(paths) {
   mkdirSync2(paths.listDir, { recursive: true });
+  if (!existsSync2(paths.lockPath)) {
+    writeFileSync2(paths.lockPath, "");
+  }
+  cleanupLegacyFiles(paths);
 }
 function readJson(path) {
   if (!existsSync2(path)) return null;
@@ -213,78 +425,27 @@ function readJson(path) {
 function writeJson(path, value) {
   writeFileSync2(path, JSON.stringify(value, null, 2), "utf8");
 }
-function appendTaskEvent(paths, event) {
-  ensureTaskListDirs(paths);
-  writeFileSync2(paths.eventsPath, `${JSON.stringify(event)}
-`, {
-    encoding: "utf8",
-    flag: "a"
-  });
-}
-function readTaskEventLog(listId, offset = 0) {
-  const paths = getTaskListPaths(listId);
-  if (!existsSync2(paths.eventsPath)) {
-    return { events: [], nextOffset: 0 };
-  }
-  const buffer = readFileSync2(paths.eventsPath);
-  const nextOffset = buffer.length;
-  if (offset >= nextOffset) {
-    return { events: [], nextOffset };
-  }
-  const chunk = buffer.toString("utf8", offset);
-  const events = [];
-  for (const line of chunk.split("\n")) {
-    if (!line.trim()) continue;
-    try {
-      const parsed = JSON.parse(line);
-      if (parsed.listId && parsed.taskId && parsed.type && parsed.timestamp) {
-        events.push(parsed);
-      }
-    } catch {
-      continue;
-    }
-  }
-  return { events, nextOffset };
-}
-function readIndex(paths) {
-  const index = readJson(paths.indexPath);
-  if (index && typeof index.nextId === "number" && index.nextId >= 1) {
-    const byStatus = index.byStatus ?? {};
-    const pending = typeof byStatus.pending === "number" ? byStatus.pending : typeof byStatus.open === "number" ? byStatus.open : 0;
-    return {
-      nextId: index.nextId,
-      total: typeof index.total === "number" ? index.total : 0,
-      byStatus: {
-        pending,
-        in_progress: typeof byStatus.in_progress === "number" ? byStatus.in_progress : 0,
-        blocked: typeof byStatus.blocked === "number" ? byStatus.blocked : 0,
-        done: typeof byStatus.done === "number" ? byStatus.done : 0,
-        archived: typeof byStatus.archived === "number" ? byStatus.archived : 0
-      },
-      lastUpdated: typeof index.lastUpdated === "number" ? index.lastUpdated : Date.now()
-    };
-  }
-  return recoverIndex(paths);
+function writeJsonAtomic(path, value) {
+  const tempPath = `${path}.${randomUUID2()}.tmp`;
+  writeFileSync2(tempPath, JSON.stringify(value, null, 2), "utf8");
+  renameSync(tempPath, path);
 }
-function writeIndex(paths, index) {
-  writeJson(paths.indexPath, index);
+function readHighwatermark(paths) {
+  if (!existsSync2(paths.highwatermarkPath)) return null;
+  const raw = readFileSync2(paths.highwatermarkPath, "utf8").trim();
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value < 0) return null;
+  return value;
 }
-function readMeta(paths) {
+function writeHighwatermark(paths, value) {
   ensureTaskListDirs(paths);
-  const meta = readJson(paths.metaPath);
-  if (meta && meta.listId) return meta;
-  const now = Date.now();
-  const created = {
-    listId: paths.listId,
-    createdAt: now,
-    updatedAt: now
-  };
-  writeJson(paths.metaPath, created);
-  return created;
+  writeFileSync2(paths.highwatermarkPath, String(value), "utf8");
 }
-function writeMeta(paths, meta) {
-  ensureTaskListDirs(paths);
-  writeJson(paths.metaPath, meta);
+function updateHighwatermark(paths, value) {
+  if (!Number.isFinite(value) || value < 0) return;
+  const current = readHighwatermark(paths);
+  const next = current !== null ? Math.max(current, value) : value;
+  writeHighwatermark(paths, next);
 }
 function readTaskFile(path) {
   const data = readJson(path);
@@ -358,6 +519,7 @@ function areBlocksEqual(a, b) {
   return true;
 }
 function readTasksFromDisk(paths) {
+  if (!existsSync2(paths.tasksDir)) return [];
   const files = readdirSync(paths.tasksDir).filter((file) => file.endsWith(".json"));
   return files.map((file) => readTaskFile(join2(paths.tasksDir, file))).filter(Boolean);
 }
@@ -390,71 +552,123 @@ function rebuildBlocksForPaths(paths) {
   const updated = persistBlocksMap(paths, map);
   return { tasks: applyBlocksMap(tasks, map), updated };
 }
-function recoverIndex(paths) {
-  ensureTaskListDirs(paths);
+var legacyFiles = ["index.json", "meta.json", "events.jsonl"];
+function cleanupLegacyFiles(paths) {
+  for (const file of legacyFiles) {
+    const path = join2(paths.listDir, file);
+    if (existsSync2(path)) {
+      rmSync(path, { force: true });
+    }
+  }
+}
+function getMaxIdFromTasksDir(paths) {
+  if (!existsSync2(paths.tasksDir)) return 0;
   const files = readdirSync(paths.tasksDir).filter((file) => file.endsWith(".json"));
-  const tasks = files.map((file) => readTaskFile(join2(paths.tasksDir, file))).filter(Boolean);
-  const byStatus = {
-    pending: 0,
-    in_progress: 0,
-    blocked: 0,
-    done: 0,
-    archived: 0
-  };
   let maxId = 0;
-  for (const task of tasks) {
-    byStatus[task.status] += 1;
-    const numericId = Number(task.id);
-    if (!Number.isNaN(numericId)) {
-      maxId = Math.max(maxId, numericId);
+  for (const file of files) {
+    const numeric = Number(file.replace(/\.json$/, ""));
+    if (Number.isFinite(numeric)) {
+      maxId = Math.max(maxId, numeric);
     }
   }
-  const index = {
-    nextId: Math.max(1, maxId + 1),
-    total: tasks.length,
-    byStatus,
-    lastUpdated: Date.now()
-  };
-  writeIndex(paths, index);
-  return index;
-}
-function readLock(path) {
-  const lock = readJson(path);
-  if (!lock || !lock.createdAt || !lock.expiresAt) return null;
-  return lock;
+  return maxId;
 }
-function isLockExpired(lock) {
-  return lock.expiresAt <= Date.now();
+function getNextTaskId(paths) {
+  const highwatermark = readHighwatermark(paths) ?? 0;
+  const maxId = getMaxIdFromTasksDir(paths);
+  return Math.max(highwatermark, maxId) + 1;
 }
 function acquireLock(paths) {
   ensureTaskListDirs(paths);
-  const lock = readLock(paths.lockPath);
-  if (lock && !isLockExpired(lock)) {
-    throw new TaskStoreLockError("Task list is locked");
-  }
-  if (lock && isLockExpired(lock)) {
-    rmSync(paths.lockPath, { force: true });
+  const start = Date.now();
+  while (taskListLocks.has(paths.lockPath)) {
+    const elapsed = Date.now() - start;
+    if (elapsed >= DEFAULT_LOCK_TIMEOUT_MS) {
+      throw new TaskStoreLockError("Task list is locked");
+    }
+    Atomics.wait(taskLockWaitBuffer, 0, 0, DEFAULT_LOCK_RETRY_MS);
   }
-  const now = Date.now();
-  try {
-    writeFileSync2(
-      paths.lockPath,
-      JSON.stringify(
-        {
-          createdAt: now,
-          expiresAt: now + DEFAULT_LOCK_TTL_MS
-        },
-        null,
-        2
-      ),
-      { encoding: "utf8", flag: "wx" }
+  const native = getNativeLock();
+  if (!native) {
+    const platformLabel = `${process.platform}-${process.arch}`;
+    const packageName = resolveNativeLockPackage();
+    if (packageName) {
+      throw new TaskStoreLockError(
+        `Native lock unavailable. Missing package ${packageName} for ${platformLabel}`
+      );
+    }
+    throw new TaskStoreLockError(
+      `Native lock unavailable. Unsupported platform ${platformLabel}`
     );
-  } catch {
-    throw new TaskStoreLockError("Task list is locked");
+  }
+  if (native.tryLockExclusivePath && native.unlockHandle) {
+    const lockKey = paths.lockPath;
+    while (true) {
+      try {
+        const handle = native.tryLockExclusivePath(lockKey);
+        if (handle > 0) {
+          taskListLocks.set(paths.lockPath, { handle, mode: "nativeHandle" });
+          return;
+        }
+      } catch {
+      }
+      const elapsed = Date.now() - start;
+      if (elapsed >= DEFAULT_LOCK_TIMEOUT_MS) {
+        throw new TaskStoreLockError("Task list is locked");
+      }
+      Atomics.wait(taskLockWaitBuffer, 0, 0, DEFAULT_LOCK_RETRY_MS);
+    }
+  }
+  while (true) {
+    const handle = openSync(paths.lockPath, "r+");
+    try {
+      const ok = native.tryLockExclusive(handle);
+      if (ok) {
+        taskListLocks.set(paths.lockPath, { handle, mode: "fd" });
+        return;
+      }
+      try {
+        closeSync(handle);
+      } catch {
+      }
+      const elapsed = Date.now() - start;
+      if (elapsed >= DEFAULT_LOCK_TIMEOUT_MS) {
+        throw new TaskStoreLockError("Task list is locked");
+      }
+      Atomics.wait(taskLockWaitBuffer, 0, 0, DEFAULT_LOCK_RETRY_MS);
+    } catch {
+      try {
+        closeSync(handle);
+      } catch {
+      }
+      const elapsed = Date.now() - start;
+      if (elapsed >= DEFAULT_LOCK_TIMEOUT_MS) {
+        throw new TaskStoreLockError("Task list is locked");
+      }
+      Atomics.wait(taskLockWaitBuffer, 0, 0, DEFAULT_LOCK_RETRY_MS);
+    }
   }
 }
 function releaseLock(paths) {
-  rmSync(paths.lockPath, { force: true });
+  const lock = taskListLocks.get(paths.lockPath);
+  if (lock !== void 0) {
+    const native = getNativeLock();
+    if (native && lock.mode === "nativeHandle" && native.unlockHandle) {
+      try {
+        native.unlockHandle(lock.handle);
+      } catch {
+      }
+    } else {
+      if (native) {
+        try {
+          native.unlock(lock.handle);
+        } catch {
+        }
+      }
+      closeSync(lock.handle);
+    }
+    taskListLocks.delete(paths.lockPath);
+  }
 }
 function withTaskListLock(paths, handler) {
   acquireLock(paths);
@@ -464,6 +678,18 @@ function withTaskListLock(paths, handler) {
     releaseLock(paths);
   }
 }
+function mergeMetadata(existing, updates) {
+  if (!updates) return existing;
+  const next = { ...existing ?? {} };
+  for (const [key, value] of Object.entries(updates)) {
+    if (value === null) {
+      delete next[key];
+    } else {
+      next[key] = value;
+    }
+  }
+  return Object.keys(next).length > 0 ? next : void 0;
+}
 function applyTaskUpdates(task, updates, nextBaseVersion) {
   const now = updates.updatedAt ?? Date.now();
   const subject = updates.subject ?? task.subject;
@@ -479,7 +705,7 @@ function applyTaskUpdates(task, updates, nextBaseVersion) {
     status,
     tags: updates.tags ?? task.tags,
     assignee: updates.assignee ?? task.assignee,
-    metadata: updates.metadata ?? task.metadata,
+    metadata: mergeMetadata(task.metadata, updates.metadata),
     archived: updates.archived ?? task.archived,
     blocks: task.blocks ?? [],
     blockedBy,
@@ -498,16 +724,12 @@ function createTask(input, options) {
   const paths = getTaskListPaths(options?.listId);
   return withTaskListLock(paths, () => {
     ensureTaskListDirs(paths);
-    const index = readIndex(paths);
-    const id = String(index.nextId);
+    const id = String(getNextTaskId(paths));
     const now = Date.now();
     const subject = input.subject;
     if (!subject) {
       throw new Error("Task subject is required");
     }
-    if (!input.activeForm) {
-      throw new Error("Task activeForm is required");
-    }
     const activeForm = input.activeForm;
     const status = input.status ?? "pending";
     if (status === "open") {
@@ -534,50 +756,55 @@ function createTask(input, options) {
       legacyTodoId: input.legacyTodoId
     };
     writeJson(join2(paths.tasksDir, `${id}.json`), record);
-    index.nextId += 1;
-    index.total += 1;
-    index.byStatus[record.status] += 1;
-    index.lastUpdated = Date.now();
-    writeIndex(paths, index);
-    const meta = readMeta(paths);
-    meta.updatedAt = Date.now();
-    writeMeta(paths, meta);
-    appendTaskEvent(paths, {
-      listId: paths.listId,
-      taskId: record.id,
-      type: "task.created",
-      timestamp: Date.now()
-    });
+    updateHighwatermark(paths, Number(id));
     const { tasks } = rebuildBlocksForPaths(paths);
     const refreshed = tasks.find((task) => task.id === record.id);
     return refreshed ?? record;
   });
 }
 function getTask(id, options) {
-  const tasks = listTasks(options);
-  return tasks.find((task) => task.id === id) ?? null;
+  const pathsList = getTaskListReadPaths(options?.listId);
+  for (const paths of pathsList) {
+    const taskPath = join2(paths.tasksDir, `${id}.json`);
+    if (!existsSync2(taskPath)) continue;
+    const task = readTaskFile(taskPath);
+    if (task) return task;
+  }
+  return null;
 }
 function listTasks(options) {
-  const paths = getTaskListPaths(options?.listId);
-  readIndex(paths);
-  ensureTaskListDirs(paths);
-  const tasks = readTasksFromDisk(paths);
-  const map = deriveBlocks(tasks);
-  const derived = applyBlocksMap(tasks, map);
-  const needsPersist = tasks.some((task) => {
-    const nextBlocks = map.get(task.id) ?? [];
-    return !areBlocksEqual(task.blocks, nextBlocks);
-  });
-  const ready = needsPersist ? withTaskListLock(paths, () => rebuildBlocksForPaths(paths).tasks) : derived;
-  return ready.sort((a, b) => Number(a.id) - Number(b.id));
+  const pathsList = getTaskListReadPaths(options?.listId);
+  const merged = /* @__PURE__ */ new Map();
+  for (const paths of pathsList) {
+    const tasks = readTasksFromDisk(paths);
+    const map = deriveBlocks(tasks);
+    const derived = applyBlocksMap(tasks, map);
+    const needsPersist = tasks.some((task) => {
+      const nextBlocks = map.get(task.id) ?? [];
+      return !areBlocksEqual(task.blocks, nextBlocks);
+    });
+    const ready = needsPersist ? withTaskListLock(paths, () => rebuildBlocksForPaths(paths).tasks) : derived;
+    for (const task of ready) {
+      if (!merged.has(task.id)) {
+        merged.set(task.id, task);
+      }
+    }
+  }
+  return Array.from(merged.values()).sort((a, b) => Number(a.id) - Number(b.id));
 }
 function updateTask(id, updates, options) {
   if (updates.status === "open") {
     throw new Error("Task status open is not supported");
   }
-  const paths = getTaskListPaths(options?.listId);
-  return withTaskListLock(paths, () => {
-    const existing = readTaskFile(join2(paths.tasksDir, `${id}.json`));
+  const pathsList = getTaskListReadPaths(options?.listId);
+  const target = pathsList.find(
+    (paths) => existsSync2(join2(paths.tasksDir, `${id}.json`))
+  );
+  if (!target) {
+    throw new Error(`Task ${id} not found`);
+  }
+  return withTaskListLock(target, () => {
+    const existing = readTaskFile(join2(target.tasksDir, `${id}.json`));
     if (!existing) {
       throw new Error(`Task ${id} not found`);
     }
@@ -598,27 +825,8 @@ function updateTask(id, updates, options) {
     }
     const nextBaseVersion = existing.baseVersion + 1;
     const updated = applyTaskUpdates(existing, updates, nextBaseVersion);
-    writeJson(join2(paths.tasksDir, `${id}.json`), updated);
-    const index = readIndex(paths);
-    if (updated.status !== existing.status) {
-      index.byStatus[existing.status] = Math.max(
-        0,
-        index.byStatus[existing.status] - 1
-      );
-      index.byStatus[updated.status] += 1;
-    }
-    index.lastUpdated = Date.now();
-    writeIndex(paths, index);
-    const meta = readMeta(paths);
-    meta.updatedAt = Date.now();
-    writeMeta(paths, meta);
-    appendTaskEvent(paths, {
-      listId: paths.listId,
-      taskId: updated.id,
-      type: "task.updated",
-      timestamp: Date.now()
-    });
-    const { tasks } = rebuildBlocksForPaths(paths);
+    writeJsonAtomic(join2(target.tasksDir, `${id}.json`), updated);
+    const { tasks } = rebuildBlocksForPaths(target);
     const refreshed = tasks.find((task) => task.id === updated.id);
     return { task: refreshed ?? updated, conflict: hasConflict };
   });
@@ -626,26 +834,16 @@ function updateTask(id, updates, options) {
 function rebuildTaskBlocks(options) {
   const paths = getTaskListPaths(options?.listId);
   return withTaskListLock(paths, () => {
-    readIndex(paths);
     ensureTaskListDirs(paths);
     const { tasks, updated } = rebuildBlocksForPaths(paths);
     return { updated, total: tasks.length };
   });
 }
-function getTaskListMeta(options) {
-  const paths = getTaskListPaths(options?.listId);
-  return readMeta(paths);
-}
-function updateTaskListMeta(meta, options) {
-  const paths = getTaskListPaths(options?.listId);
-  const updated = { ...meta, updatedAt: Date.now() };
-  writeMeta(paths, updated);
-  return updated;
-}
 
 // src/utils/session/todoStorage.ts
 var TODO_STORAGE_KEY = "todos";
 var TODO_CONFIG_KEY = "todoConfig";
+var TODO_MIGRATION_KEY = "todoMigration";
 var DEFAULT_CONFIG = {
   maxTodos: 100,
   autoArchiveCompleted: false,
@@ -710,22 +908,24 @@ function syncTodosToTasks(todos, options) {
 }
 function migrateTodosToTasks(options) {
   const { listId } = getTaskListPaths(options?.listId);
-  const meta = getTaskListMeta({ listId });
-  if (meta.todoMigration?.completedAt) {
+  const migrationKey = `${listId}:${options?.agentId ?? "default"}`;
+  const sessionState = getSessionState();
+  const migrationState = sessionState[TODO_MIGRATION_KEY] ?? {};
+  if (migrationState[migrationKey]?.completedAt) {
     return { listId, migrated: false, created: 0 };
   }
   const todos = getTodos(options?.agentId);
   const result = syncTodosToTasks(todos, { listId });
-  updateTaskListMeta(
-    {
-      ...meta,
-      todoMigration: {
+  setSessionState({
+    ...sessionState,
+    [TODO_MIGRATION_KEY]: {
+      ...migrationState,
+      [migrationKey]: {
         completedAt: Date.now(),
         sourceCount: todos.length
       }
-    },
-    { listId }
-  );
+    }
+  });
   return { listId, migrated: true, created: result.created };
 }
 function invalidateCache() {
@@ -903,38 +1103,10 @@ var SystemReminderService = class {
         "todo",
         "task",
         "medium",
-        "This is a reminder that your task list is currently empty. DO NOT mention this to the user explicitly because they are already aware. If you are working on tasks that would benefit from a structured plan, use TaskCreate to seed tasks and TaskUpdate to track progress. Use TaskList to review readiness. If not, please feel free to ignore. Again do not mention this message to the user.",
+        "This is a reminder that your task list is currently empty. DO NOT mention this to the user explicitly because they are already aware. If you are working on tasks that would benefit from a structured plan, use TaskCreate once to provide a complete task list (no dependencies); the tool will finalize dependencies internally. Use TaskList to review readiness. If not, please feel free to ignore. Again do not mention this message to the user.",
         currentTime
       );
     }
-    if (todos.length > 0) {
-      const reminderKey = `todo_updated_${agentKey}_${todos.length}_${this.getTodoStateHash(todos)}`;
-      if (this.reminderCache.has(reminderKey)) {
-        return this.reminderCache.get(reminderKey);
-      }
-      if (!this.sessionState.remindersSent.has(reminderKey)) {
-        this.sessionState.remindersSent.add(reminderKey);
-        this.clearTodoReminders(agentKey);
-        const todoContent = JSON.stringify(
-          todos.map((todo) => ({
-            content: todo.content.length > 100 ? todo.content.substring(0, 100) + "..." : todo.content,
-            status: todo.status,
-            activeForm: todo.activeForm && todo.activeForm.length > 100 ? todo.activeForm.substring(0, 100) + "..." : todo.activeForm || todo.content
-          }))
-        );
-        const reminder = this.createReminderMessage(
-          "todo",
-          "task",
-          "medium",
-          `Your task items have changed. DO NOT mention this explicitly to the user. Here are the latest contents of your tracked items:
-
-${todoContent}. Use TaskList to review readiness and TaskUpdate to adjust status if needed.`,
-          currentTime
-        );
-        this.reminderCache.set(reminderKey, reminder);
-        return reminder;
-      }
-    }
     return null;
   }
   dispatchSecurityEvent() {
@@ -1357,9 +1529,12 @@ var resetReminderSession = () => systemReminderService.resetSession();
 export {
   getAgentFilePath,
   generateAgentId,
+  generateTaskListId,
+  runWithTaskListId,
+  runWithTaskListEnv,
   TaskStoreConflictError,
   getTaskListPaths,
-  readTaskEventLog,
+  initTaskListLockFile,
   createTask,
   getTask,
   listTasks,