pybao-cli 1.4.37 → 1.4.39

package/dist/chunk-AI7FJQR4.js

@@ -0,0 +1,1262 @@
+import { createRequire as __pybCreateRequire } from "node:module";
+const require = __pybCreateRequire(import.meta.url);
+import {
+  getSessionState,
+  setSessionState
+} from "./chunk-ERMQRV55.js";
+import {
+  getCurrentProjectConfig,
+  getGlobalConfig
+} from "./chunk-TNAAGT3Q.js";
+import {
+  debug
+} from "./chunk-O5OT26P6.js";
+import {
+  getCwd,
+  logError,
+  resolveXdgDataPath
+} from "./chunk-ZGVGFR4C.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,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  readdirSync,
+  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;
+function buildActiveForm(subject) {
+  return `Working on ${subject}`;
+}
+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 createHash("sha256").update(cwd).digest("hex").slice(0, 12);
+}
+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 ?? 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 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 (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 getTaskListPaths(listId) {
+  const context = getTaskListContext({ listId });
+  const cwd = getCwd();
+  const baseDir = resolveTaskBaseDir(context, cwd);
+  const listDir = join2(baseDir, context.listId);
+  return {
+    listId: context.listId,
+    baseDir,
+    listDir,
+    tasksDir: listDir,
+    indexPath: join2(listDir, "index.json"),
+    metaPath: join2(listDir, "meta.json"),
+    lockPath: join2(listDir, ".lock"),
+    eventsPath: join2(listDir, "events.jsonl")
+  };
+}
+function ensureTaskListDirs(paths) {
+  mkdirSync2(paths.listDir, { recursive: true });
+}
+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 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 && index.nextId >= 1) return index;
+  return recoverIndex(paths);
+}
+function writeIndex(paths, index) {
+  writeJson(paths.indexPath, index);
+}
+function readMeta(paths) {
+  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;
+}
+function writeMeta(paths, meta) {
+  ensureTaskListDirs(paths);
+  writeJson(paths.metaPath, meta);
+}
+function readTaskFile(path) {
+  const data = readJson(
+    path
+  );
+  if (!data || !data.id || !data.subject && !data.title || !data.status) {
+    return null;
+  }
+  const subject = data.subject ?? data.title;
+  const title = subject;
+  const activeForm = data.activeForm ?? buildActiveForm(subject);
+  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 = {
+    ...data,
+    subject,
+    title,
+    activeForm,
+    blocks: data.blocks ?? [],
+    blockedBy: data.blockedBy ?? [],
+    createdAt,
+    updatedAt,
+    baseVersion,
+    version
+  };
+  delete normalized.priority;
+  return normalized;
+}
+function recoverIndex(paths) {
+  ensureTaskListDirs(paths);
+  const files = readdirSync(paths.tasksDir).filter((file) => file.endsWith(".json"));
+  const tasks = files.map((file) => readTaskFile(join2(paths.tasksDir, file))).filter(Boolean);
+  const byStatus = {
+    open: 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);
+    }
+  }
+  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;
+}
+function isLockExpired(lock) {
+  return lock.expiresAt <= Date.now();
+}
+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 now = Date.now();
+  try {
+    writeFileSync2(
+      paths.lockPath,
+      JSON.stringify(
+        {
+          createdAt: now,
+          expiresAt: now + DEFAULT_LOCK_TTL_MS
+        },
+        null,
+        2
+      ),
+      { encoding: "utf8", flag: "wx" }
+    );
+  } catch {
+    throw new TaskStoreLockError("Task list is locked");
+  }
+}
+function releaseLock(paths) {
+  rmSync(paths.lockPath, { force: true });
+}
+function withTaskListLock(paths, handler) {
+  acquireLock(paths);
+  try {
+    return handler();
+  } finally {
+    releaseLock(paths);
+  }
+}
+function applyTaskUpdates(task, updates, nextBaseVersion) {
+  const now = updates.updatedAt ?? Date.now();
+  const subject = updates.subject ?? task.subject;
+  const title = subject;
+  const activeForm = updates.activeForm ?? (updates.subject ? buildActiveForm(subject) : task.activeForm ?? buildActiveForm(subject));
+  const blocks = updates.blocks ?? task.blocks ?? [];
+  const blockedBy = updates.blockedBy ?? task.blockedBy ?? [];
+  return {
+    ...task,
+    subject,
+    title,
+    description: updates.description ?? task.description,
+    activeForm,
+    status: updates.status ?? task.status,
+    tags: updates.tags ?? task.tags,
+    assignee: updates.assignee ?? task.assignee,
+    metadata: updates.metadata ?? task.metadata,
+    archived: updates.archived ?? task.archived,
+    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) {
+  const paths = getTaskListPaths(options?.listId);
+  return withTaskListLock(paths, () => {
+    ensureTaskListDirs(paths);
+    const index = readIndex(paths);
+    const id = String(index.nextId);
+    const now = Date.now();
+    const subject = input.subject;
+    if (!subject) {
+      throw new Error("Task subject is required");
+    }
+    const title = subject;
+    const activeForm = input.activeForm ?? buildActiveForm(subject);
+    const record = {
+      id,
+      subject,
+      title,
+      description: input.description,
+      activeForm,
+      status: input.status ?? "open",
+      tags: input.tags,
+      assignee: input.assignee,
+      metadata: input.metadata,
+      archived: input.archived,
+      blocks: input.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);
+    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()
+    });
+    return record;
+  });
+}
+function getTask(id, options) {
+  const paths = getTaskListPaths(options?.listId);
+  const record = readTaskFile(join2(paths.tasksDir, `${id}.json`));
+  if (!record) return null;
+  return record;
+}
+function listTasks(options) {
+  const paths = getTaskListPaths(options?.listId);
+  readIndex(paths);
+  ensureTaskListDirs(paths);
+  const files = readdirSync(paths.tasksDir).filter((file) => file.endsWith(".json"));
+  const tasks = files.map((file) => readTaskFile(join2(paths.tasksDir, file))).filter(Boolean);
+  return tasks.sort((a, b) => Number(a.id) - Number(b.id));
+}
+function updateTask(id, updates, options) {
+  const paths = getTaskListPaths(options?.listId);
+  return withTaskListLock(paths, () => {
+    const existing = readTaskFile(join2(paths.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);
+    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()
+    });
+    return { task: updated, conflict: hasConflict };
+  });
+}
+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 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 "open";
+}
+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 meta = getTaskListMeta({ listId });
+  if (meta.todoMigration?.completedAt) {
+    return { listId, migrated: false, created: 0 };
+  }
+  const todos = getTodos(options?.agentId);
+  const result = syncTodosToTasks(todos, { listId });
+  updateTaskListMeta(
+    {
+      ...meta,
+      todoMigration: {
+        completedAt: Date.now(),
+        sourceCount: todos.length
+      }
+    },
+    { listId }
+  );
+  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 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.",
+        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() {
+    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.open}_${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}, Open: ${summary.open}, 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?.title || 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?.title || 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,
+  TaskStoreConflictError,
+  getTaskListPaths,
+  readTaskEventLog,
+  createTask,
+  getTask,
+  listTasks,
+  updateTask,
+  isTodoCompatEnabled,
+  syncTodosToTasks,
+  migrateTodosToTasks,
+  getTodos,
+  setTodos,
+  systemReminderService,
+  generateSystemReminders,
+  emitReminderEvent,
+  resetReminderSession
+};