pybao-cli 1.4.51 → 1.4.52

package/dist/chunk-L2FQX7IL.js

@@ -1,1552 +0,0 @@
-import { createRequire as __pybCreateRequire } from "node:module";
-const require = __pybCreateRequire(import.meta.url);
-import {
-  getSessionState,
-  setSessionState
-} from "./chunk-ERMQRV55.js";
-import {
-  getPybAgentSessionId
-} from "./chunk-B6IMQJZM.js";
-import {
-  getCurrentProjectConfig,
-  getGlobalConfig
-} from "./chunk-LEQNJ73H.js";
-import {
-  debug
-} from "./chunk-6MFZG46W.js";
-import {
-  getCwd,
-  logError,
-  resolveXdgDataPath
-} from "./chunk-HJDETBB6.js";
-
-// src/utils/agent/storage.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { join } from "path";
-import { randomUUID } from "crypto";
-function getConfigDirectory() {
-  const override = process.env.ANYKODE_CONFIG_DIR?.trim();
-  if (override) return override;
-  return resolveXdgDataPath("agents");
-}
-function getSessionId() {
-  return process.env.ANYKODE_SESSION_ID ?? "default-session";
-}
-function getAgentFilePath(agentId) {
-  const sessionId = getSessionId();
-  const filename = `${sessionId}-agent-${agentId}.json`;
-  const configDir = getConfigDirectory();
-  if (!existsSync(configDir)) {
-    mkdirSync(configDir, { recursive: true });
-  }
-  return join(configDir, filename);
-}
-function readAgentData(agentId) {
-  const filePath = getAgentFilePath(agentId);
-  if (!existsSync(filePath)) {
-    return null;
-  }
-  try {
-    const content = readFileSync(filePath, "utf-8");
-    return JSON.parse(content);
-  } catch (error) {
-    logError(error);
-    debug.warn("AGENT_STORAGE_READ_FAILED", {
-      agentId,
-      error: error instanceof Error ? error.message : String(error)
-    });
-    return null;
-  }
-}
-function writeAgentData(agentId, data) {
-  const filePath = getAgentFilePath(agentId);
-  try {
-    writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
-  } catch (error) {
-    logError(error);
-    debug.warn("AGENT_STORAGE_WRITE_FAILED", {
-      agentId,
-      error: error instanceof Error ? error.message : String(error)
-    });
-    throw error;
-  }
-}
-function getDefaultAgentId() {
-  return "default";
-}
-function resolveAgentId(agentId) {
-  return agentId || getDefaultAgentId();
-}
-function generateAgentId() {
-  return randomUUID();
-}
-
-// 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 { 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) {
-    super(message);
-    this.name = "TaskStoreLockError";
-  }
-};
-var TaskStoreConflictError = class extends Error {
-  code = "TASK_STORE_CONFLICT";
-  taskId;
-  expectedBaseVersion;
-  actualBaseVersion;
-  constructor(params) {
-    super(
-      `Task ${params.taskId} baseVersion ${params.actual} does not match expected ${params.expected}`
-    );
-    this.name = "TaskStoreConflictError";
-    this.taskId = params.taskId;
-    this.expectedBaseVersion = params.expected;
-    this.actualBaseVersion = params.actual;
-  }
-};
-function getDefaultTaskListId(cwd) {
-  return getPybAgentSessionId();
-}
-function resolveGlobalTaskRootDir() {
-  const override = process.env.PYB_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR;
-  if (override) return override;
-  const home = homedir();
-  const pybDir = join2(home, ".pyb");
-  if (existsSync2(pybDir)) return pybDir;
-  const claudeDir = join2(home, ".claude");
-  if (existsSync2(claudeDir)) return claudeDir;
-  return pybDir;
-}
-function findBaseDirWithList(listId, candidates) {
-  for (const candidate of candidates) {
-    if (existsSync2(join2(candidate, listId))) return candidate;
-  }
-  return null;
-}
-function getTaskListContext(options) {
-  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();
-  if (inputListId) {
-    if (inputListId === projectId || inputListId === defaultId) {
-      return { listId: inputListId, scope: "project", source: "input" };
-    }
-    if (inputListId === globalId || inputListId === envId) {
-      return { listId: inputListId, scope: "global", source: "input" };
-    }
-    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" };
-  return { listId: defaultId, scope: "project", source: "default" };
-}
-function resolveTaskBaseDir(context, cwd) {
-  if (context.scope === "project") {
-    const pybDir = join2(cwd, ".pyb");
-    const claudeDir = join2(cwd, ".claude");
-    const hasProjectPyb = existsSync2(pybDir);
-    const hasProjectClaude = existsSync2(claudeDir);
-    const projectRoot = hasProjectPyb ? pybDir : hasProjectClaude ? claudeDir : pybDir;
-    const override2 = process.env.PYB_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR;
-    const defaultBaseDir2 = !hasProjectPyb && !hasProjectClaude && override2 ? join2(override2, "tasks") : join2(projectRoot, "tasks");
-    const candidates2 = [
-      join2(cwd, ".pyb", "tasks"),
-      join2(cwd, ".claude", "tasks"),
-      ...override2 ? [join2(override2, "tasks")] : [],
-      resolveXdgDataPath("tasks")
-    ];
-    return findBaseDirWithList(context.listId, candidates2) ?? defaultBaseDir2;
-  }
-  const override = process.env.PYB_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR;
-  const globalCandidates = override ? [join2(override, "tasks")] : [
-    join2(homedir(), ".pyb", "tasks"),
-    join2(homedir(), ".claude", "tasks")
-  ];
-  const defaultBaseDir = join2(resolveGlobalTaskRootDir(), "tasks");
-  const candidates = [...globalCandidates, resolveXdgDataPath("tasks")];
-  return findBaseDirWithList(context.listId, candidates) ?? defaultBaseDir;
-}
-function buildTaskListPaths(baseDir, listId) {
-  const listDir = join2(baseDir, listId);
-  return {
-    listId,
-    baseDir,
-    listDir,
-    tasksDir: listDir,
-    lockPath: join2(listDir, ".lock"),
-    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;
-  try {
-    const raw = readFileSync2(path, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function writeJson(path, value) {
-  writeFileSync2(path, JSON.stringify(value, null, 2), "utf8");
-}
-function writeJsonAtomic(path, value) {
-  const tempPath = `${path}.${randomUUID2()}.tmp`;
-  writeFileSync2(tempPath, JSON.stringify(value, null, 2), "utf8");
-  renameSync(tempPath, path);
-}
-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 writeHighwatermark(paths, value) {
-  ensureTaskListDirs(paths);
-  writeFileSync2(paths.highwatermarkPath, String(value), "utf8");
-}
-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);
-  if (!data || !data.id || !data.subject && !data.title || !data.status) {
-    return null;
-  }
-  const status = data.status === "open" ? "pending" : data.status;
-  if (status !== "pending" && status !== "in_progress" && status !== "blocked" && status !== "done" && status !== "archived") {
-    return null;
-  }
-  const subject = data.subject ?? data.title;
-  const activeForm = data.activeForm;
-  const baseVersion = typeof data.baseVersion === "number" ? data.baseVersion : typeof data.version === "number" ? data.version : 1;
-  const version = typeof data.version === "number" ? data.version : baseVersion;
-  const createdAt = typeof data.createdAt === "number" ? data.createdAt : Date.now();
-  const updatedAt = typeof data.updatedAt === "number" ? data.updatedAt : createdAt;
-  const normalized = {
-    id: data.id,
-    subject,
-    description: data.description,
-    activeForm,
-    status,
-    tags: data.tags,
-    assignee: data.assignee,
-    metadata: data.metadata,
-    archived: data.archived,
-    blocks: data.blocks ?? [],
-    blockedBy: data.blockedBy ?? [],
-    parent: data.parent,
-    related: data.related ?? [],
-    createdAt,
-    updatedAt,
-    baseVersion,
-    version,
-    legacyTodoId: data.legacyTodoId
-  };
-  delete normalized.priority;
-  return normalized;
-}
-function deriveBlocks(tasks) {
-  const map = /* @__PURE__ */ new Map();
-  for (const task of tasks) {
-    map.set(task.id, []);
-  }
-  for (const task of tasks) {
-    const blockers = task.blockedBy ?? [];
-    for (const blockerId of blockers) {
-      const list = map.get(blockerId);
-      if (list) {
-        list.push(task.id);
-      } else {
-        map.set(blockerId, [task.id]);
-      }
-    }
-  }
-  for (const [key, list] of map.entries()) {
-    map.set(
-      key,
-      list.sort((a, b) => Number(a) - Number(b))
-    );
-  }
-  return map;
-}
-function areBlocksEqual(a, b) {
-  const left = a ?? [];
-  const right = b ?? [];
-  if (left.length !== right.length) return false;
-  for (let i = 0; i < left.length; i += 1) {
-    if (left[i] !== right[i]) return false;
-  }
-  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);
-}
-function applyBlocksMap(tasks, map) {
-  return tasks.map((task) => ({
-    ...task,
-    blocks: map.get(task.id) ?? []
-  }));
-}
-function persistBlocksMap(paths, map) {
-  ensureTaskListDirs(paths);
-  const files = readdirSync(paths.tasksDir).filter((file) => file.endsWith(".json"));
-  let updated = 0;
-  for (const file of files) {
-    const path = join2(paths.tasksDir, file);
-    const raw = readJson(path);
-    if (!raw || !raw.id) continue;
-    const nextBlocks = map.get(raw.id) ?? [];
-    const currentBlocks = Array.isArray(raw.blocks) ? raw.blocks : [];
-    if (areBlocksEqual(currentBlocks, nextBlocks)) continue;
-    raw.blocks = nextBlocks;
-    writeJson(path, raw);
-    updated += 1;
-  }
-  return updated;
-}
-function rebuildBlocksForPaths(paths) {
-  const tasks = readTasksFromDisk(paths);
-  const map = deriveBlocks(tasks);
-  const updated = persistBlocksMap(paths, map);
-  return { tasks: applyBlocksMap(tasks, map), updated };
-}
-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"));
-  let maxId = 0;
-  for (const file of files) {
-    const numeric = Number(file.replace(/\.json$/, ""));
-    if (Number.isFinite(numeric)) {
-      maxId = Math.max(maxId, numeric);
-    }
-  }
-  return maxId;
-}
-function getNextTaskId(paths) {
-  const highwatermark = readHighwatermark(paths) ?? 0;
-  const maxId = getMaxIdFromTasksDir(paths);
-  return Math.max(highwatermark, maxId) + 1;
-}
-function acquireLock(paths) {
-  ensureTaskListDirs(paths);
-  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 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}`
-    );
-  }
-  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) {
-  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);
-  try {
-    return handler();
-  } finally {
-    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;
-  const activeForm = updates.activeForm ?? task.activeForm;
-  const blockedBy = updates.blockedBy ?? task.blockedBy ?? [];
-  const nextStatus = updates.status ?? task.status;
-  const status = nextStatus === "open" ? task.status : nextStatus;
-  return {
-    ...task,
-    subject,
-    description: updates.description ?? task.description,
-    activeForm,
-    status,
-    tags: updates.tags ?? task.tags,
-    assignee: updates.assignee ?? task.assignee,
-    metadata: mergeMetadata(task.metadata, updates.metadata),
-    archived: updates.archived ?? task.archived,
-    blocks: task.blocks ?? [],
-    blockedBy,
-    parent: updates.parent ?? task.parent,
-    related: updates.related ?? task.related,
-    updatedAt: now,
-    baseVersion: nextBaseVersion,
-    version: nextBaseVersion,
-    legacyTodoId: updates.legacyTodoId ?? task.legacyTodoId
-  };
-}
-function createTask(input, options) {
-  if (input.status === "open") {
-    throw new Error("Task status open is not supported");
-  }
-  const paths = getTaskListPaths(options?.listId);
-  return withTaskListLock(paths, () => {
-    ensureTaskListDirs(paths);
-    const id = String(getNextTaskId(paths));
-    const now = Date.now();
-    const subject = input.subject;
-    if (!subject) {
-      throw new Error("Task subject is required");
-    }
-    const activeForm = input.activeForm;
-    const status = input.status ?? "pending";
-    if (status === "open") {
-      throw new Error("Task status open is not supported");
-    }
-    const record = {
-      id,
-      subject,
-      description: input.description,
-      activeForm,
-      status,
-      tags: input.tags,
-      assignee: input.assignee,
-      metadata: input.metadata,
-      archived: input.archived,
-      blocks: [],
-      blockedBy: input.blockedBy ?? [],
-      parent: input.parent,
-      related: input.related,
-      createdAt: now,
-      updatedAt: now,
-      baseVersion: 1,
-      version: 1,
-      legacyTodoId: input.legacyTodoId
-    };
-    writeJson(join2(paths.tasksDir, `${id}.json`), record);
-    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 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 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 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`);
-    }
-    const requestedBase = updates.baseVersion;
-    const hasConflict = typeof requestedBase === "number" && requestedBase !== existing.baseVersion;
-    if (hasConflict && !options?.allowMerge) {
-      throw new TaskStoreConflictError({
-        taskId: id,
-        expected: requestedBase,
-        actual: existing.baseVersion
-      });
-    }
-    if (hasConflict && options?.allowMerge) {
-      const updateTimestamp = updates.updatedAt ?? Date.now();
-      if (updateTimestamp <= existing.updatedAt) {
-        return { task: existing, conflict: true };
-      }
-    }
-    const nextBaseVersion = existing.baseVersion + 1;
-    const updated = applyTaskUpdates(existing, updates, nextBaseVersion);
-    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 };
-  });
-}
-function rebuildTaskBlocks(options) {
-  const paths = getTaskListPaths(options?.listId);
-  return withTaskListLock(paths, () => {
-    ensureTaskListDirs(paths);
-    const { tasks, updated } = rebuildBlocksForPaths(paths);
-    return { updated, total: tasks.length };
-  });
-}
-
-// 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,
-  sortBy: "status",
-  sortOrder: "desc"
-};
-var todoCache = null;
-var cacheTimestamp = 0;
-var CACHE_TTL = 5e3;
-function isTodoCompatEnabled(env = process.env) {
-  const raw = String(
-    env.PYB_TODO_COMPAT ?? env.CLAUDE_CODE_TODO_COMPAT ?? ""
-  ).trim().toLowerCase();
-  if (!raw) return false;
-  if (["0", "false", "no", "off"].includes(raw)) return false;
-  if (["1", "true", "yes", "on"].includes(raw)) return true;
-  return true;
-}
-function toTaskStatus(status) {
-  if (status === "completed") return "done";
-  if (status === "in_progress") return "in_progress";
-  return "pending";
-}
-function syncTodosToTasks(todos, options) {
-  const { listId } = getTaskListPaths(options?.listId);
-  const tasks = listTasks({ listId });
-  const byLegacyId = new Map(
-    tasks.filter((task) => task.legacyTodoId).map((task) => [task.legacyTodoId, task])
-  );
-  let created = 0;
-  let updated = 0;
-  for (const todo of todos) {
-    const existing = byLegacyId.get(todo.id);
-    if (!existing) {
-      createTask(
-        {
-          subject: todo.content,
-          description: todo.content,
-          activeForm: todo.activeForm,
-          status: toTaskStatus(todo.status),
-          legacyTodoId: todo.id
-        },
-        { listId }
-      );
-      created += 1;
-    } else {
-      updateTask(
-        existing.id,
-        {
-          subject: todo.content,
-          description: todo.content,
-          activeForm: todo.activeForm,
-          status: toTaskStatus(todo.status),
-          legacyTodoId: todo.id
-        },
-        { listId, allowMerge: true }
-      );
-      updated += 1;
-    }
-  }
-  return { listId, created, updated };
-}
-function migrateTodosToTasks(options) {
-  const { listId } = getTaskListPaths(options?.listId);
-  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 });
-  setSessionState({
-    ...sessionState,
-    [TODO_MIGRATION_KEY]: {
-      ...migrationState,
-      [migrationKey]: {
-        completedAt: Date.now(),
-        sourceCount: todos.length
-      }
-    }
-  });
-  return { listId, migrated: true, created: result.created };
-}
-function invalidateCache() {
-  todoCache = null;
-  cacheTimestamp = 0;
-}
-function updateMetrics(operation, cacheHit = false) {
-  const sessionState = getSessionState();
-  const metrics = sessionState.todoMetrics || {
-    totalOperations: 0,
-    cacheHits: 0,
-    cacheMisses: 0,
-    lastOperation: 0
-  };
-  metrics.totalOperations++;
-  metrics.lastOperation = Date.now();
-  if (cacheHit) {
-    metrics.cacheHits++;
-  } else {
-    metrics.cacheMisses++;
-  }
-  setSessionState({
-    ...sessionState,
-    todoMetrics: metrics
-  });
-}
-function getTodos(agentId) {
-  const resolvedAgentId = resolveAgentId(agentId);
-  const now = Date.now();
-  if (agentId) {
-    updateMetrics("getTodos", false);
-    const agentTodos = readAgentData(resolvedAgentId) || [];
-    const agentCacheKey = `todoCache_${resolvedAgentId}`;
-    return agentTodos.map((todo) => ({
-      ...todo,
-      activeForm: todo.activeForm || todo.content
-    }));
-  }
-  if (todoCache && now - cacheTimestamp < CACHE_TTL) {
-    updateMetrics("getTodos", true);
-    return todoCache.map((todo) => ({
-      ...todo,
-      activeForm: todo.activeForm || todo.content
-    }));
-  }
-  updateMetrics("getTodos", false);
-  const sessionState = getSessionState();
-  const todos = sessionState[TODO_STORAGE_KEY] || [];
-  todoCache = [...todos].map((todo) => ({
-    ...todo,
-    activeForm: todo.activeForm || todo.content
-  }));
-  cacheTimestamp = now;
-  return todoCache;
-}
-function setTodos(todos, agentId) {
-  const resolvedAgentId = resolveAgentId(agentId);
-  const config = getTodoConfig();
-  const existingTodos = getTodos(agentId);
-  if (agentId) {
-    if (todos.length > config.maxTodos) {
-      throw new Error(
-        `Todo limit exceeded. Maximum ${config.maxTodos} todos allowed.`
-      );
-    }
-    let processedTodos2 = todos;
-    if (config.autoArchiveCompleted) {
-      processedTodos2 = todos.filter((todo) => todo.status !== "completed");
-    }
-    const updatedTodos2 = processedTodos2.map((todo) => {
-      const existingTodo = existingTodos.find(
-        (existing) => existing.id === todo.id
-      );
-      return {
-        ...todo,
-        activeForm: todo.activeForm || todo.content,
-        updatedAt: Date.now(),
-        createdAt: todo.createdAt || Date.now(),
-        previousStatus: existingTodo?.status !== todo.status ? existingTodo?.status : todo.previousStatus
-      };
-    });
-    writeAgentData(resolvedAgentId, updatedTodos2);
-    updateMetrics("setTodos");
-    return;
-  }
-  if (todos.length > config.maxTodos) {
-    throw new Error(
-      `Todo limit exceeded. Maximum ${config.maxTodos} todos allowed.`
-    );
-  }
-  let processedTodos = todos;
-  if (config.autoArchiveCompleted) {
-    processedTodos = todos.filter((todo) => todo.status !== "completed");
-  }
-  const updatedTodos = processedTodos.map((todo) => {
-    const existingTodo = existingTodos.find((existing) => existing.id === todo.id);
-    return {
-      ...todo,
-      activeForm: todo.activeForm || todo.content,
-      updatedAt: Date.now(),
-      createdAt: todo.createdAt || Date.now(),
-      previousStatus: existingTodo?.status !== todo.status ? existingTodo?.status : todo.previousStatus
-    };
-  });
-  setSessionState({
-    ...getSessionState(),
-    [TODO_STORAGE_KEY]: updatedTodos
-  });
-  invalidateCache();
-  updateMetrics("setTodos");
-}
-function getTodoConfig() {
-  const sessionState = getSessionState();
-  return { ...DEFAULT_CONFIG, ...sessionState[TODO_CONFIG_KEY] || {} };
-}
-
-// src/services/system/systemReminder.ts
-var SystemReminderService = class {
-  sessionState = {
-    lastTodoUpdate: 0,
-    lastFileAccess: 0,
-    lastTaskUpdate: 0,
-    sessionStartTime: Date.now(),
-    remindersSent: /* @__PURE__ */ new Set(),
-    contextPresent: false,
-    reminderCount: 0,
-    taskEventTimestamps: /* @__PURE__ */ new Map(),
-    config: {
-      todoEmptyReminder: true,
-      securityReminder: true,
-      performanceReminder: true,
-      maxRemindersPerSession: 10
-    }
-  };
-  eventDispatcher = /* @__PURE__ */ new Map();
-  reminderCache = /* @__PURE__ */ new Map();
-  constructor() {
-    this.setupEventDispatcher();
-  }
-  generateReminders(hasContext = false, agentId) {
-    this.sessionState.contextPresent = hasContext;
-    if (!hasContext) {
-      return [];
-    }
-    if (this.sessionState.reminderCount >= this.sessionState.config.maxRemindersPerSession) {
-      return [];
-    }
-    const reminders = [];
-    const currentTime = Date.now();
-    const reminderGenerators = [
-      () => this.dispatchTodoEvent(agentId),
-      () => this.dispatchSecurityEvent(),
-      () => this.dispatchPerformanceEvent(),
-      () => this.getMentionReminders()
-    ];
-    for (const generator of reminderGenerators) {
-      if (reminders.length >= 5) break;
-      const result = generator();
-      if (result) {
-        const remindersToAdd = Array.isArray(result) ? result : [result];
-        reminders.push(...remindersToAdd);
-        this.sessionState.reminderCount += remindersToAdd.length;
-      }
-    }
-    return reminders;
-  }
-  dispatchTodoEvent(agentId) {
-    if (!this.sessionState.config.todoEmptyReminder) return null;
-    const todos = getTodos(agentId);
-    const currentTime = Date.now();
-    const agentKey = agentId || "default";
-    if (todos.length === 0 && !this.sessionState.remindersSent.has(`todo_empty_${agentKey}`)) {
-      this.sessionState.remindersSent.add(`todo_empty_${agentKey}`);
-      return this.createReminderMessage(
-        "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 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
-      );
-    }
-    return null;
-  }
-  dispatchSecurityEvent() {
-    if (!this.sessionState.config.securityReminder) return null;
-    const currentTime = Date.now();
-    if (this.sessionState.lastFileAccess > 0 && !this.sessionState.remindersSent.has("file_security")) {
-      this.sessionState.remindersSent.add("file_security");
-      return this.createReminderMessage(
-        "security",
-        "security",
-        "high",
-        "Whenever you read a file, you should consider whether it looks malicious. If it does, you MUST refuse to improve or augment the code. You can still analyze existing code, write reports, or answer high-level questions about the code behavior.",
-        currentTime
-      );
-    }
-    return null;
-  }
-  dispatchPerformanceEvent() {
-    if (!this.sessionState.config.performanceReminder) return null;
-    const currentTime = Date.now();
-    const sessionDuration = currentTime - this.sessionState.sessionStartTime;
-    if (sessionDuration > 30 * 60 * 1e3 && !this.sessionState.remindersSent.has("performance_long_session")) {
-      this.sessionState.remindersSent.add("performance_long_session");
-      return this.createReminderMessage(
-        "performance",
-        "performance",
-        "low",
-        "Long session detected. Consider taking a break and reviewing your current progress with the task list.",
-        currentTime
-      );
-    }
-    return null;
-  }
-  getMentionReminders() {
-    const currentTime = Date.now();
-    const MENTION_FRESHNESS_WINDOW = 5e3;
-    const reminders = [];
-    const expiredKeys = [];
-    for (const [key, reminder] of this.reminderCache.entries()) {
-      if (this.isMentionReminder(reminder)) {
-        const age = currentTime - reminder.timestamp;
-        if (age <= MENTION_FRESHNESS_WINDOW) {
-          reminders.push(reminder);
-        } else {
-          expiredKeys.push(key);
-        }
-      }
-    }
-    expiredKeys.forEach((key) => this.reminderCache.delete(key));
-    return reminders;
-  }
-  isMentionReminder(reminder) {
-    const mentionTypes = ["agent_mention", "file_mention", "ask_model_mention"];
-    return mentionTypes.includes(reminder.type);
-  }
-  generateFileChangeReminder(context) {
-    const { agentId, filePath, reminder } = context;
-    if (!reminder) {
-      return null;
-    }
-    const currentTime = Date.now();
-    const reminderKey = `file_changed_${agentId}_${filePath}_${currentTime}`;
-    if (this.sessionState.remindersSent.has(reminderKey)) {
-      return null;
-    }
-    this.sessionState.remindersSent.add(reminderKey);
-    return this.createReminderMessage(
-      "file_changed",
-      "general",
-      "medium",
-      reminder,
-      currentTime
-    );
-  }
-  createReminderMessage(type, category, priority, content, timestamp) {
-    return {
-      role: "system",
-      content: `<system-reminder>
-${content}
-</system-reminder>`,
-      isMeta: true,
-      timestamp,
-      type,
-      priority,
-      category
-    };
-  }
-  getTodoStateHash(todos) {
-    return todos.map((t) => `${t.content}:${t.status}:${t.activeForm || t.content}`).sort().join("|");
-  }
-  clearTodoReminders(agentId) {
-    const agentKey = agentId || "default";
-    for (const key of this.sessionState.remindersSent) {
-      if (key.startsWith(`todo_updated_${agentKey}_`)) {
-        this.sessionState.remindersSent.delete(key);
-      }
-    }
-  }
-  shouldEmitTaskReminder(key, throttleMs) {
-    const now = Date.now();
-    const last = this.sessionState.taskEventTimestamps.get(key) ?? 0;
-    if (now - last < throttleMs) {
-      return false;
-    }
-    this.sessionState.taskEventTimestamps.set(key, now);
-    return true;
-  }
-  createTaskListReminder(context) {
-    const { listId, summary } = context;
-    if (!summary || !listId) return null;
-    const reminderKey = `task_list_${listId}_${summary.total}_${summary.ready}_${summary.blocked}_${summary.inProgress}_${summary.pending}_${summary.done}_${summary.archived}`;
-    if (this.sessionState.remindersSent.has(reminderKey)) return null;
-    this.sessionState.remindersSent.add(reminderKey);
-    return this.createReminderMessage(
-      "task_list_changed",
-      "task",
-      "medium",
-      `Your task list changed. Ready: ${summary.ready}, Blocked: ${summary.blocked}, In progress: ${summary.inProgress}, Pending: ${summary.pending}, Done: ${summary.done}, Archived: ${summary.archived}.`,
-      Date.now()
-    );
-  }
-  createTaskReadyReminder(context) {
-    const { listId, readyIds } = context;
-    if (!listId || !Array.isArray(readyIds)) return null;
-    const limited = readyIds.slice(0, 5).join(", ");
-    const reminderKey = `task_ready_${listId}_${readyIds.length}_${limited}`;
-    if (this.sessionState.remindersSent.has(reminderKey)) return null;
-    this.sessionState.remindersSent.add(reminderKey);
-    return this.createReminderMessage(
-      "task_ready_changed",
-      "task",
-      "medium",
-      `Task readiness changed. Ready count: ${readyIds.length}. Ready ids: ${limited || "none"}.`,
-      Date.now()
-    );
-  }
-  createTaskConflictReminder(context) {
-    const { listId, taskId } = context;
-    if (!listId || !taskId) return null;
-    const reminderKey = `task_conflict_${listId}_${taskId}`;
-    if (this.sessionState.remindersSent.has(reminderKey)) return null;
-    this.sessionState.remindersSent.add(reminderKey);
-    return this.createReminderMessage(
-      "task_conflict",
-      "task",
-      "high",
-      `Task update conflict detected for ${taskId}. Refresh task data and retry updates with the latest baseVersion.`,
-      Date.now()
-    );
-  }
-  createTaskCreatedReminder(context) {
-    const { listId, taskId, task } = context;
-    if (!listId || !taskId) return null;
-    const reminderKey = `task_created_${listId}_${taskId}`;
-    if (this.sessionState.remindersSent.has(reminderKey)) return null;
-    this.sessionState.remindersSent.add(reminderKey);
-    const subject = task?.subject || taskId;
-    return this.createReminderMessage(
-      "task_created",
-      "task",
-      "medium",
-      `Task created: ${subject} (${taskId}). Review details and adjust status if needed.`,
-      Date.now()
-    );
-  }
-  createTaskUpdatedReminder(context) {
-    const { listId, taskId, task } = context;
-    if (!listId || !taskId) return null;
-    const reminderKey = `task_updated_${listId}_${taskId}_${task?.baseVersion ?? ""}`;
-    if (this.sessionState.remindersSent.has(reminderKey)) return null;
-    this.sessionState.remindersSent.add(reminderKey);
-    const subject = task?.subject || taskId;
-    return this.createReminderMessage(
-      "task_updated",
-      "task",
-      "medium",
-      `Task updated: ${subject} (${taskId}). Confirm dependencies and status are correct.`,
-      Date.now()
-    );
-  }
-  createTaskStatusReminder(context) {
-    const { listId, taskId, previousStatus, status } = context;
-    if (!listId || !taskId) return null;
-    const reminderKey = `task_status_${listId}_${taskId}_${previousStatus}_${status}`;
-    if (this.sessionState.remindersSent.has(reminderKey)) return null;
-    this.sessionState.remindersSent.add(reminderKey);
-    return this.createReminderMessage(
-      "task_status_changed",
-      "task",
-      "medium",
-      `Task status changed for ${taskId}: ${previousStatus} \u2192 ${status}. Review dependent tasks if needed.`,
-      Date.now()
-    );
-  }
-  createTaskDepsReminder(context) {
-    const { listId, taskId, deps } = context;
-    if (!listId || !taskId) return null;
-    const reminderKey = `task_deps_${listId}_${taskId}_${JSON.stringify(deps ?? {})}`;
-    if (this.sessionState.remindersSent.has(reminderKey)) return null;
-    this.sessionState.remindersSent.add(reminderKey);
-    return this.createReminderMessage(
-      "task_deps_changed",
-      "task",
-      "medium",
-      `Task dependencies changed for ${taskId}. Recheck readiness and blockers.`,
-      Date.now()
-    );
-  }
-  setupEventDispatcher() {
-    this.addEventListener("session:startup", (context) => {
-      this.resetSession();
-      this.sessionState.sessionStartTime = Date.now();
-      this.sessionState.contextPresent = Object.keys(context.context || {}).length > 0;
-    });
-    this.addEventListener("todo:changed", (context) => {
-      this.sessionState.lastTodoUpdate = Date.now();
-      this.clearTodoReminders(context.agentId);
-    });
-    this.addEventListener("todo:file_changed", (context) => {
-      const agentId = context.agentId || "default";
-      this.clearTodoReminders(agentId);
-      this.sessionState.lastTodoUpdate = Date.now();
-      const reminder = this.generateFileChangeReminder(context);
-      if (reminder) {
-        this.emitEvent("reminder:inject", {
-          reminder: reminder.content,
-          agentId,
-          type: "file_changed",
-          timestamp: Date.now()
-        });
-      }
-    });
-    this.addEventListener("task:list_changed", (context) => {
-      const key = `task_list_${context.listId}`;
-      if (!this.shouldEmitTaskReminder(key, 2e3)) return;
-      this.sessionState.lastTaskUpdate = Date.now();
-      const reminder = this.createTaskListReminder(context);
-      if (reminder) {
-        this.emitEvent("reminder:inject", {
-          reminder: reminder.content,
-          listId: context.listId,
-          type: "task_list_changed",
-          timestamp: Date.now()
-        });
-      }
-    });
-    this.addEventListener("task:ready_changed", (context) => {
-      const key = `task_ready_${context.listId}`;
-      if (!this.shouldEmitTaskReminder(key, 2e3)) return;
-      const reminder = this.createTaskReadyReminder(context);
-      if (reminder) {
-        this.emitEvent("reminder:inject", {
-          reminder: reminder.content,
-          listId: context.listId,
-          type: "task_ready_changed",
-          timestamp: Date.now()
-        });
-      }
-    });
-    this.addEventListener("task:conflict_detected", (context) => {
-      const key = `task_conflict_${context.listId}_${context.taskId}`;
-      if (!this.shouldEmitTaskReminder(key, 2e3)) return;
-      const reminder = this.createTaskConflictReminder(context);
-      if (reminder) {
-        this.emitEvent("reminder:inject", {
-          reminder: reminder.content,
-          listId: context.listId,
-          type: "task_conflict",
-          timestamp: Date.now()
-        });
-      }
-    });
-    this.addEventListener("task.created", (context) => {
-      const key = `task_created_${context.listId}_${context.taskId}`;
-      if (!this.shouldEmitTaskReminder(key, 2e3)) return;
-      const reminder = this.createTaskCreatedReminder(context);
-      if (reminder) {
-        this.emitEvent("reminder:inject", {
-          reminder: reminder.content,
-          listId: context.listId,
-          type: reminder.type,
-          timestamp: reminder.timestamp
-        });
-      }
-    });
-    this.addEventListener("task.updated", (context) => {
-      const key = `task_updated_${context.listId}_${context.taskId}`;
-      if (!this.shouldEmitTaskReminder(key, 2e3)) return;
-      const reminder = this.createTaskUpdatedReminder(context);
-      if (reminder) {
-        this.emitEvent("reminder:inject", {
-          reminder: reminder.content,
-          listId: context.listId,
-          type: reminder.type,
-          timestamp: reminder.timestamp
-        });
-      }
-    });
-    this.addEventListener("task.status_changed", (context) => {
-      const key = `task_status_${context.listId}_${context.taskId}`;
-      if (!this.shouldEmitTaskReminder(key, 2e3)) return;
-      const reminder = this.createTaskStatusReminder(context);
-      if (reminder) {
-        this.emitEvent("reminder:inject", {
-          reminder: reminder.content,
-          listId: context.listId,
-          type: reminder.type,
-          timestamp: reminder.timestamp
-        });
-      }
-    });
-    this.addEventListener("task.deps_changed", (context) => {
-      const key = `task_deps_${context.listId}_${context.taskId}`;
-      if (!this.shouldEmitTaskReminder(key, 2e3)) return;
-      const reminder = this.createTaskDepsReminder(context);
-      if (reminder) {
-        this.emitEvent("reminder:inject", {
-          reminder: reminder.content,
-          listId: context.listId,
-          type: reminder.type,
-          timestamp: reminder.timestamp
-        });
-      }
-    });
-    this.addEventListener("file:read", (context) => {
-      this.sessionState.lastFileAccess = Date.now();
-    });
-    this.addEventListener("file:edited", (context) => {
-    });
-    this.addEventListener("agent:mentioned", (context) => {
-      this.createMentionReminder({
-        type: "agent_mention",
-        key: `agent_mention_${context.agentType}_${context.timestamp}`,
-        category: "task",
-        priority: "high",
-        content: `The user mentioned @${context.originalMention}. You MUST use the Task tool with subagent_type="${context.agentType}" to delegate this task to the specified agent. Provide a detailed, self-contained task description that fully captures the user's intent for the ${context.agentType} agent to execute.`,
-        timestamp: context.timestamp
-      });
-    });
-    this.addEventListener("file:mentioned", (context) => {
-      this.createMentionReminder({
-        type: "file_mention",
-        key: `file_mention_${context.filePath}_${context.timestamp}`,
-        category: "general",
-        priority: "high",
-        content: `The user mentioned @${context.originalMention}. You MUST read the entire content of the file at path: ${context.filePath} using the Read tool to understand the full context before proceeding with the user's request.`,
-        timestamp: context.timestamp
-      });
-    });
-    this.addEventListener("ask-model:mentioned", (context) => {
-      this.createMentionReminder({
-        type: "ask_model_mention",
-        key: `ask_model_mention_${context.modelName}_${context.timestamp}`,
-        category: "task",
-        priority: "high",
-        content: `The user mentioned @${context.modelName}. You MUST use the AskExpertModelTool to consult this specific model for expert opinions and analysis. Provide the user's question or context clearly to get the most relevant response from ${context.modelName}.`,
-        timestamp: context.timestamp
-      });
-    });
-  }
-  addEventListener(event, callback) {
-    if (!this.eventDispatcher.has(event)) {
-      this.eventDispatcher.set(event, []);
-    }
-    this.eventDispatcher.get(event).push(callback);
-  }
-  emitEvent(event, context) {
-    const listeners = this.eventDispatcher.get(event) || [];
-    listeners.forEach((callback) => {
-      try {
-        callback(context);
-      } catch (error) {
-        logError(error);
-        debug.warn("SYSTEM_REMINDER_LISTENER_ERROR", {
-          event,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    });
-  }
-  createMentionReminder(params) {
-    if (!this.sessionState.remindersSent.has(params.key)) {
-      this.sessionState.remindersSent.add(params.key);
-      const reminder = this.createReminderMessage(
-        params.type,
-        params.category,
-        params.priority,
-        params.content,
-        params.timestamp
-      );
-      this.reminderCache.set(params.key, reminder);
-    }
-  }
-  resetSession() {
-    this.sessionState = {
-      lastTodoUpdate: 0,
-      lastFileAccess: 0,
-      lastTaskUpdate: 0,
-      sessionStartTime: Date.now(),
-      remindersSent: /* @__PURE__ */ new Set(),
-      contextPresent: false,
-      reminderCount: 0,
-      taskEventTimestamps: /* @__PURE__ */ new Map(),
-      config: { ...this.sessionState.config }
-    };
-    this.reminderCache.clear();
-  }
-  updateConfig(config) {
-    this.sessionState.config = { ...this.sessionState.config, ...config };
-  }
-  getSessionState() {
-    return { ...this.sessionState };
-  }
-};
-var systemReminderService = new SystemReminderService();
-var generateSystemReminders = (hasContext = false, agentId) => systemReminderService.generateReminders(hasContext, agentId);
-var emitReminderEvent = (event, context) => systemReminderService.emitEvent(event, context);
-var resetReminderSession = () => systemReminderService.resetSession();
-
-export {
-  getAgentFilePath,
-  generateAgentId,
-  generateTaskListId,
-  runWithTaskListId,
-  runWithTaskListEnv,
-  TaskStoreConflictError,
-  getTaskListPaths,
-  initTaskListLockFile,
-  createTask,
-  getTask,
-  listTasks,
-  updateTask,
-  rebuildTaskBlocks,
-  isTodoCompatEnabled,
-  syncTodosToTasks,
-  migrateTodosToTasks,
-  getTodos,
-  setTodos,
-  systemReminderService,
-  generateSystemReminders,
-  emitReminderEvent,
-  resetReminderSession
-};