natureco-cli 5.7.0 → 5.7.2

package/src/tools/memory_write.js

@@ -8,53 +8,93 @@
 const fs = require("fs");
 const path = require("path");
 const os = require("os");
+const { writeJsonAtomicSync, readJsonSafeSync } = require("../utils/atomic-file");
 
 const MEMORY_DIR = path.join(os.homedir(), ".natureco", "memory");
 
+// Soft cap on per-user fact count. Decay already prunes old/low-importance
+// facts; this just bounds the worst-case file size and prompt-injection
+// surface. Configurable via NATURECO_MAX_FACTS (default 50, was a hard 15
+// that was silently truncating new writes when full).
+const MAX_FACTS_PER_USER = (() => {
+  const raw = parseInt(process.env.NATURECO_MAX_FACTS || "", 10);
+  return Number.isFinite(raw) && raw > 0 ? raw : 50;
+})();
+
 function getMemoryFile(username) {
   const name = (username || "default").toLowerCase();
   return path.join(MEMORY_DIR, `${name}.json`);
 }
 
+function _emptyMemory(username) {
+  return { name: username || "User", nickname: null, botName: null, facts: [], preferences: [] };
+}
+
 function loadMemory(username) {
-  const file = getMemoryFile(username);
-  try {
-    if (!fs.existsSync(file)) {
-      return { name: username || "User", nickname: null, botName: null, facts: [], preferences: [] };
-    }
-    return JSON.parse(fs.readFileSync(file, "utf8"));
-  } catch {
-    return { name: username || "User", nickname: null, botName: null, facts: [], preferences: [] };
-  }
+  return readJsonSafeSync(getMemoryFile(username), _emptyMemory(username));
 }
 
 function saveMemory(username, memory) {
   if (!fs.existsSync(MEMORY_DIR)) fs.mkdirSync(MEMORY_DIR, { recursive: true });
   memory.lastUpdated = new Date().toISOString();
-  fs.writeFileSync(getMemoryFile(username), JSON.stringify(memory, null, 2), "utf8");
+  writeJsonAtomicSync(getMemoryFile(username), memory);
   return memory;
 }
 
 /**
- * Score azalt (eski fact'ler zamanla unutuluyor)
+ * Score azalt (eski fact'ler zamanla unutulur).
+ * Sıralama veya soft-cap UYGULAMAZ — onu enforceFactLimit yapar
+ * (push'tan sonra çağrılır, böylece yeni fact silinmez).
  */
 function decayFacts(memory) {
   if (!memory.facts) return memory;
   const now = Date.now();
   memory.facts = memory.facts.map(f => {
     if (!f.score) f.score = 5;
-    // 1 haftadan eski -1, 1 aydan eski -3
     const ageMs = now - new Date(f.updatedAt || f.createdAt || now).getTime();
     const ageDays = ageMs / (1000 * 60 * 60 * 24);
     if (ageDays > 30) f.score = Math.max(0, f.score - 3);
     else if (ageDays > 7) f.score = Math.max(0, f.score - 1);
     return f;
   });
-  // score 0 olanlari sil
   memory.facts = memory.facts.filter(f => (f.score || 0) > 0);
-  // max 15 fact tut
-  memory.facts.sort((a, b) => (b.score || 0) - (a.score || 0));
-  memory.facts = memory.facts.slice(0, 15);
+  return memory;
+}
+
+/**
+ * Soft cap: yeni fact eklenmesinden SONRA uygulanır, böylece az önce
+ * yazılan fact eviction kurbanı olmaz. En düşük score + en eski updatedAt
+ * önce gider. Cap aşılırsa stderr'e tek satır warn yazar (eski "silent
+ * truncate to 15" davranışını gözlemlenebilir hale getirir).
+ *
+ * @param {{facts: Array<object>}} memory
+ * @param {{recentValue?: string}} [opts]  Korunması zorunlu fact (yeni eklenen)
+ * @returns the same memory
+ */
+function enforceFactLimit(memory, opts = {}) {
+  if (!memory.facts || memory.facts.length <= MAX_FACTS_PER_USER) return memory;
+  const before = memory.facts.length;
+  const recent = opts.recentValue ? opts.recentValue.toLowerCase() : null;
+  // Sort by score desc, then updatedAt desc (newest+highest first).
+  // The just-pushed fact is pinned at the top regardless of its score.
+  memory.facts.sort((a, b) => {
+    if (recent) {
+      if ((a.value || "").toLowerCase() === recent) return -1;
+      if ((b.value || "").toLowerCase() === recent) return 1;
+    }
+    const sa = a.score || 0, sb = b.score || 0;
+    if (sa !== sb) return sb - sa;
+    return String(b.updatedAt || "").localeCompare(String(a.updatedAt || ""));
+  });
+  memory.facts = memory.facts.slice(0, MAX_FACTS_PER_USER);
+  const dropped = before - memory.facts.length;
+  if (dropped > 0 && !process.env.NATURECO_QUIET_MEMORY) {
+    // eslint-disable-next-line no-console
+    console.warn(
+      `[memory] cap ${MAX_FACTS_PER_USER} aşıldı, en düşük skorlu ${dropped} fact düşürüldü ` +
+      `(NATURECO_MAX_FACTS ile değiştir, NATURECO_QUIET_MEMORY=1 ile sustur)`
+    );
+  }
   return memory;
 }
 
@@ -122,6 +162,8 @@ function addMemory({ username, fact, score = 5, category = "general", botName, n
         createdAt: new Date().toISOString(),
       });
     }
+    // Limit'i ZIM push'tan sonra uygula → yeni eklenen fact düşürülmez.
+    memory = enforceFactLimit(memory, { recentValue: fact });
   }
 
   if (!memory.preferences) memory.preferences = [];
@@ -173,6 +215,18 @@ function showMemory({ username }) {
 }
 
 module.exports = {
+  // Exposed for tests / advanced consumers — not part of the tool schema.
+  _internals: {
+    MAX_FACTS_PER_USER,
+    enforceFactLimit,
+    decayFacts,
+    loadMemory,
+    saveMemory,
+    addMemory,
+    clearMemory,
+    showMemory,
+    getMemoryFile,
+  },
   name: "memory_write",
   description: "Memory'ye yeni fact/bilgi kaydet veya bot ismini/nickname'i degistir. Kalici, REPL'in extractMemoryFromMessage ozelligi.",
   inputSchema: {

package/src/tools/read_file.js

@@ -1,75 +1,134 @@
+/**
+ * read_file — Read a file's contents.
+ *
+ * Backwards-compatible upgrade (v5.7.1): the old call shape
+ * `{ path }` still works and still returns `{success, path, content, size,
+ * truncated}` exactly as before. The new options add Claude Code-style
+ * pagination + line-numbered output:
+ *
+ *   - `offset` (line number, 1-based): skip the first N-1 lines.
+ *   - `limit`  (line count): read at most this many lines.
+ *   - `numbered` (bool): if true, prefix each line with its 1-based
+ *     line number + a tab (matches `cat -n`); useful when the agent
+ *     then needs to call edit_file and wants to cite exact lines.
+ *
+ * Other safety touches retained from the original:
+ *   - File-existence + not-a-file checks.
+ *   - 1 MB cap before falling into "show me 50 KB" mode (raised to
+ *     2 MB now that line-based pagination exists — the agent can ask
+ *     for `{offset, limit}` instead).
+ *   - Returns `{success: false, error}` rather than throwing.
+ */
 const fs = require('fs');
-const path = require('path');
-const os = require('os');
 
-module.exports = {
-  name: 'read_file',
-  description: 'PRIMARY TOOL: Read a specific file content. Use this when user wants to read/view/look at a single file. For listing directories use filesystem tool.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      path: {
-        type: 'string',
-        description: 'File path to read'
-      }
-    },
-    required: ['path']
-  },
-  
-  async execute(params) {
-    try {
-      // v5.2.0: Robust path expansion (~, ~/, relative)
-      const { expandPath } = require('../utils/paths');
-      const filePath = expandPath(params.path);
-      
-      if (!fs.existsSync(filePath)) {
-        return {
-          success: false,
-          error: 'File does not exist'
-        };
-      }
-      
-      const stats = fs.statSync(filePath);
-      
-      if (!stats.isFile()) {
-        return {
-          success: false,
-          error: 'Path is not a file'
-        };
-      }
-      
-      // Check file size - if > 1MB, read only first 50KB
-      if (stats.size > 1024 * 1024) {
-        const fd = fs.openSync(filePath, 'r');
-        const buf = Buffer.alloc(50000);
-        fs.readSync(fd, buf, 0, 50000, 0);
-        fs.closeSync(fd);
-        
-        const content = '[Büyük dosya - ilk ~50KB gösteriliyor]\n' + buf.toString('utf8');
-        
-        return {
-          success: true,
-          path: filePath,
-          content,
-          size: stats.size,
-          truncated: true
-        };
-      }
-      
-      const content = fs.readFileSync(filePath, 'utf-8');
-      
+const DEFAULT_LINE_LIMIT = 2000;   // matches Claude Code's Read default
+const HARD_BYTE_CAP = 2 * 1024 * 1024; // 2 MB — agent should paginate above this
+const SOFT_BYTE_PREVIEW = 50_000;       // bytes shown for the "file too large" preview
+
+function _formatNumbered(text, startLine) {
+  const lines = text.split('\n');
+  let out = '';
+  for (let i = 0; i < lines.length; i++) {
+    out += String(startLine + i) + '\t' + lines[i];
+    if (i < lines.length - 1) out += '\n';
+  }
+  return out;
+}
+
+async function readFile(params) {
+  try {
+    const { expandPath } = require('../utils/paths');
+    const filePath = expandPath(params.path);
+
+    if (!fs.existsSync(filePath)) {
+      return { success: false, error: 'File does not exist' };
+    }
+
+    const stats = fs.statSync(filePath);
+    if (!stats.isFile()) {
+      return { success: false, error: 'Path is not a file' };
+    }
+
+    const offset = Math.max(1, Number(params.offset) || 1);
+    const limit = params.limit !== undefined ? Math.max(1, Number(params.limit)) : null;
+    const numbered = !!params.numbered;
+    const wantsPagination = params.offset !== undefined || params.limit !== undefined;
+
+    // Large-file guard. With pagination the agent can read what it needs;
+    // without it we still show a useful preview (matches old behavior).
+    if (stats.size > HARD_BYTE_CAP && !wantsPagination) {
+      const fd = fs.openSync(filePath, 'r');
+      const buf = Buffer.alloc(SOFT_BYTE_PREVIEW);
+      fs.readSync(fd, buf, 0, SOFT_BYTE_PREVIEW, 0);
+      fs.closeSync(fd);
+      const preview = '[Büyük dosya — ilk ~50KB gösteriliyor; offset/limit ile sayfalayın]\n' + buf.toString('utf8');
       return {
         success: true,
         path: filePath,
-        content,
+        content: preview,
         size: stats.size,
-        truncated: false
+        truncated: true,
       };
-    } catch (error) {
+    }
+
+    const raw = fs.readFileSync(filePath, 'utf-8');
+
+    if (!wantsPagination && !numbered) {
+      // Original return shape — keep byte-for-byte compatible.
       return {
-        success: false,
-        error: error.message
+        success: true,
+        path: filePath,
+        content: raw,
+        size: stats.size,
+        truncated: false,
       };
     }
+
+    // Pagination + optional line numbers.
+    const allLines = raw.split('\n');
+    const totalLines = allLines.length;
+    const start = Math.min(offset, totalLines + 1) - 1; // to 0-based
+    const effectiveLimit = limit !== null ? limit : DEFAULT_LINE_LIMIT;
+    const end = Math.min(start + effectiveLimit, totalLines);
+    const slice = allLines.slice(start, end);
+    const sliceText = slice.join('\n');
+    const content = numbered ? _formatNumbered(sliceText, start + 1) : sliceText;
+
+    return {
+      success: true,
+      path: filePath,
+      content,
+      size: stats.size,
+      truncated: end < totalLines,
+      total_lines: totalLines,
+      lines_returned: slice.length,
+      offset: start + 1,
+      limit: effectiveLimit,
+      numbered,
+    };
+  } catch (error) {
+    return { success: false, error: error.message };
   }
+}
+
+module.exports = {
+  name: 'read_file',
+  description:
+    'PRIMARY TOOL: Read a file. Supports Claude Code-style pagination ' +
+    '(offset + limit, 1-based line numbers) and optional `numbered` output ' +
+    '(prefixes each line with its number + tab, matching `cat -n`). ' +
+    'For listing directories use the filesystem tool. For ranges past 2000 ' +
+    'lines, call again with a new offset.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      path: { type: 'string', description: 'File path to read (absolute or ~-prefix)' },
+      offset: { type: 'integer', description: '1-based line number to start at (default 1)', minimum: 1 },
+      limit: { type: 'integer', description: `Maximum lines to return (default ${DEFAULT_LINE_LIMIT})`, minimum: 1 },
+      numbered: { type: 'boolean', description: 'Prefix each line with its 1-based line number + tab (cat -n format)', default: false },
+    },
+    required: ['path'],
+  },
+  execute: readFile,
+  _internals: { readFile, _formatNumbered },
 };

package/src/tools/todo_write.js

@@ -1,88 +1,255 @@
 /**
- * todo_write - Yapilacaklar listesi (v4.9.0)
+ * todo_write — Task / todo manager.
  *
- * Hermes todo_write'una benzer.
+ * Upgrade (v5.7.1) modeled after Claude Code's TaskCreate/TaskUpdate/
+ * TaskList semantics so the agent can track multi-step work like
+ * `pending → in_progress → completed`, name an `activeForm` for the
+ * spinner, and express dependencies via `blockedBy` / `blocks`.
+ *
+ * Backwards compatibility: every old action (list/add/done/remove/
+ * clear) and the old `{content, priority, status: 'done'}` shape keeps
+ * working byte-for-byte — see the test file for the locked-in shape.
+ * The on-disk JSON gains new fields but old `{id, content, status,
+ * priority, createdAt, completedAt}` entries are still read correctly.
  */
 
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { writeJsonAtomicSync, readJsonSafeSync } = require('../utils/atomic-file');
+
+const TODO_FILE = path.join(os.homedir(), '.natureco', 'todos.json');
 
-const TODO_FILE = path.join(os.homedir(), ".natureco", "todos.json");
+const VALID_STATUSES = new Set(['pending', 'in_progress', 'completed', 'deleted']);
+const VALID_PRIORITIES = new Set(['low', 'medium', 'high']);
 
-function loadTodos() {
-  try {
-    if (!fs.existsSync(TODO_FILE)) return [];
-    return JSON.parse(fs.readFileSync(TODO_FILE, "utf8"));
-  } catch { return []; }
+function _loadTodos() {
+  const data = readJsonSafeSync(TODO_FILE, []);
+  return Array.isArray(data) ? data : [];
 }
 
-function saveTodos(todos) {
+function _saveTodos(todos) {
   fs.mkdirSync(path.dirname(TODO_FILE), { recursive: true });
-  fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2), "utf8");
+  writeJsonAtomicSync(TODO_FILE, todos);
 }
 
-function genId() {
+function _genId() {
   return Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
 }
 
-async function todoAction({ action = "list", content, id, priority = "medium", status }) {
-  let todos = loadTodos();
+function _normalizeStatus(s) {
+  if (!s) return null;
+  // accept legacy 'done' as alias for 'completed'
+  if (s === 'done') return 'completed';
+  return VALID_STATUSES.has(s) ? s : null;
+}
+
+function _normalizeTodo(t) {
+  // Migrate old shape on the fly so listing always returns a uniform
+  // structure even for entries written by v5.6 and earlier.
+  return {
+    id: t.id,
+    subject: t.subject || t.content || '(no subject)',
+    description: t.description || '',
+    activeForm: t.activeForm || t.subject || t.content || '',
+    status: _normalizeStatus(t.status) || 'pending',
+    priority: VALID_PRIORITIES.has(t.priority) ? t.priority : 'medium',
+    owner: t.owner || null,
+    blockedBy: Array.isArray(t.blockedBy) ? t.blockedBy : [],
+    blocks: Array.isArray(t.blocks) ? t.blocks : [],
+    metadata: (t.metadata && typeof t.metadata === 'object') ? t.metadata : {},
+    createdAt: t.createdAt || new Date().toISOString(),
+    updatedAt: t.updatedAt || t.createdAt || new Date().toISOString(),
+    completedAt: t.completedAt || null,
+  };
+}
 
-  if (action === "list") {
-    const pending = todos.filter(t => t.status === "pending");
-    const done = todos.filter(t => t.status === "done");
-    return { success: true, total: todos.length, pending: pending.length, done: done.length, todos: pending };
+function _isBlocked(todo, allTodos) {
+  if (!todo.blockedBy || todo.blockedBy.length === 0) return false;
+  const openIds = new Set(
+    allTodos.filter(t => t.status !== 'completed' && t.status !== 'deleted').map(t => t.id),
+  );
+  return todo.blockedBy.some(id => openIds.has(id));
+}
+
+async function todoAction(params) {
+  const action = params.action || 'list';
+  let todos = _loadTodos().map(_normalizeTodo);
+
+  // ─────────────────── LIST / GET ───────────────────
+  if (action === 'list' || action === 'get') {
+    if (action === 'get') {
+      if (!params.id) return { success: false, error: 'id gerekli' };
+      const t = todos.find(x => x.id === params.id);
+      if (!t) return { success: false, error: `Todo bulunamadı: ${params.id}` };
+      return { success: true, todo: t };
+    }
+    // Filter by status if specified
+    const filtered = params.status
+      ? todos.filter(t => t.status === _normalizeStatus(params.status))
+      : todos.filter(t => t.status !== 'deleted');
+    // Annotate with blockedBy state
+    const annotated = filtered.map(t => ({
+      ...t,
+      currently_blocked: _isBlocked(t, todos),
+    }));
+    return {
+      success: true,
+      total: todos.filter(t => t.status !== 'deleted').length,
+      pending: todos.filter(t => t.status === 'pending').length,
+      in_progress: todos.filter(t => t.status === 'in_progress').length,
+      completed: todos.filter(t => t.status === 'completed').length,
+      todos: annotated,
+    };
   }
 
-  if (action === "add") {
-    if (!content) return { success: false, error: "content gerekli" };
-    const todo = { id: genId(), content, priority, status: "pending", createdAt: new Date().toISOString() };
+  // ─────────────────── ADD / CREATE ───────────────────
+  if (action === 'add' || action === 'create') {
+    const subject = params.subject || params.content;
+    if (!subject) return { success: false, error: 'subject (veya content) gerekli' };
+    const todo = _normalizeTodo({
+      id: _genId(),
+      subject,
+      description: params.description || '',
+      activeForm: params.activeForm || subject,
+      status: 'pending',
+      priority: params.priority || 'medium',
+      owner: params.owner || null,
+      blockedBy: Array.isArray(params.blockedBy) ? params.blockedBy : [],
+      blocks: Array.isArray(params.blocks) ? params.blocks : [],
+      metadata: params.metadata || {},
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
     todos.push(todo);
-    saveTodos(todos);
-    return { success: true, todo, message: `Todo eklendi: ${content}` };
+    // Bidirectional link: if A blocks B, B is blockedBy A.
+    for (const blockedId of todo.blocks) {
+      const other = todos.find(t => t.id === blockedId);
+      if (other && !other.blockedBy.includes(todo.id)) {
+        other.blockedBy.push(todo.id);
+        other.updatedAt = new Date().toISOString();
+      }
+    }
+    _saveTodos(todos);
+    return { success: true, todo, message: `Görev eklendi: ${subject}` };
   }
 
-  if (action === "done") {
-    if (!id) return { success: false, error: "id gerekli" };
-    const todo = todos.find(t => t.id === id);
-    if (!todo) return { success: false, error: `Todo bulunamadi: ${id}` };
-    todo.status = "done";
-    todo.completedAt = new Date().toISOString();
-    saveTodos(todos);
-    return { success: true, todo, message: `Tamamlandi: ${todo.content}` };
+  // ─────────────────── UPDATE / START / DONE / REOPEN ───────────────────
+  if (action === 'update' || action === 'start' || action === 'done' || action === 'completed' || action === 'reopen') {
+    if (!params.id) return { success: false, error: 'id gerekli' };
+    const idx = todos.findIndex(t => t.id === params.id);
+    if (idx < 0) return { success: false, error: `Todo bulunamadı: ${params.id}` };
+
+    const todo = todos[idx];
+
+    if (action === 'start') {
+      // Refuse to start if blocked
+      if (_isBlocked(todo, todos)) {
+        return {
+          success: false,
+          error: `Görev bloklu — şu açık görevler bitmeden başlayamaz: ${todo.blockedBy.join(', ')}`,
+          blockedBy: todo.blockedBy,
+        };
+      }
+      todo.status = 'in_progress';
+    } else if (action === 'done' || action === 'completed') {
+      todo.status = 'completed';
+      todo.completedAt = new Date().toISOString();
+    } else if (action === 'reopen') {
+      todo.status = 'pending';
+      todo.completedAt = null;
+    } else if (action === 'update') {
+      if (params.subject !== undefined) todo.subject = params.subject;
+      if (params.description !== undefined) todo.description = params.description;
+      if (params.activeForm !== undefined) todo.activeForm = params.activeForm;
+      if (params.priority !== undefined && VALID_PRIORITIES.has(params.priority)) {
+        todo.priority = params.priority;
+      }
+      if (params.status !== undefined) {
+        const ns = _normalizeStatus(params.status);
+        if (ns) todo.status = ns;
+        if (ns === 'completed') todo.completedAt = new Date().toISOString();
+      }
+      if (params.owner !== undefined) todo.owner = params.owner;
+      if (Array.isArray(params.addBlockedBy)) {
+        for (const blockId of params.addBlockedBy) {
+          if (!todo.blockedBy.includes(blockId)) todo.blockedBy.push(blockId);
+        }
+      }
+      if (Array.isArray(params.addBlocks)) {
+        for (const blockedId of params.addBlocks) {
+          if (!todo.blocks.includes(blockedId)) todo.blocks.push(blockedId);
+          const other = todos.find(t => t.id === blockedId);
+          if (other && !other.blockedBy.includes(todo.id)) other.blockedBy.push(todo.id);
+        }
+      }
+      if (params.metadata && typeof params.metadata === 'object') {
+        for (const [k, v] of Object.entries(params.metadata)) {
+          if (v === null) delete todo.metadata[k];
+          else todo.metadata[k] = v;
+        }
+      }
+    }
+    todo.updatedAt = new Date().toISOString();
+    _saveTodos(todos);
+    return { success: true, todo, message: `Güncellendi: ${todo.subject}` };
   }
 
-  if (action === "remove") {
-    if (!id) return { success: false, error: "id gerekli" };
+  // ─────────────────── REMOVE / CLEAR ───────────────────
+  if (action === 'remove' || action === 'delete') {
+    if (!params.id) return { success: false, error: 'id gerekli' };
     const before = todos.length;
-    todos = todos.filter(t => t.id !== id);
-    saveTodos(todos);
+    todos = todos.filter(t => t.id !== params.id);
+    // Also clean up any blockedBy references that now point at nothing
+    for (const t of todos) {
+      t.blockedBy = t.blockedBy.filter(bid => todos.some(x => x.id === bid));
+      t.blocks = t.blocks.filter(bid => todos.some(x => x.id === bid));
+    }
+    _saveTodos(todos);
     return { success: true, removed: before - todos.length };
   }
 
-  if (action === "clear") {
-    saveTodos([]);
-    return { success: true, cleared: todos.length, message: "Tum todolar temizlendi" };
+  if (action === 'clear') {
+    const n = todos.length;
+    _saveTodos([]);
+    return { success: true, cleared: n, message: 'Tüm görevler temizlendi' };
   }
 
   return { success: false, error: `Bilinmeyen action: ${action}` };
 }
 
 module.exports = {
-  name: "todo_write",
-  description: "Yapilacaklar listesi. action: list, add, done, remove, clear.",
+  name: 'todo_write',
+  description:
+    'Görev / todo yöneticisi. action: list, get, add (alias: create), ' +
+    'update, start (pending→in_progress, blokluysa reddeder), ' +
+    'done (alias: completed), reopen, remove (alias: delete), clear. ' +
+    'Yeni alanlar: subject, description, activeForm (spinner için), ' +
+    'priority, owner, blockedBy, blocks, metadata. Legacy {content, ' +
+    'status: "done"} çağrıları hala geçerli.',
   inputSchema: {
-    type: "object",
+    type: 'object',
     properties: {
-      action: { type: "string", description: "list/add/done/remove/clear (default: list)", enum: ["list", "add", "done", "remove", "clear"] },
-      content: { type: "string", description: "Todo icerigi (add icin)" },
-      id: { type: "string", description: "Todo ID (done/remove icin)" },
-      priority: { type: "string", description: "Oncelik: low/medium/high (add icin)", enum: ["low", "medium", "high"] },
-      status: { type: "string", description: "Durum filtresi: pending/done" },
+      action: {
+        type: 'string',
+        description: 'list / get / add / create / update / start / done / completed / reopen / remove / delete / clear',
+        enum: ['list', 'get', 'add', 'create', 'update', 'start', 'done', 'completed', 'reopen', 'remove', 'delete', 'clear'],
+      },
+      id: { type: 'string', description: 'Görev ID (get/update/start/done/reopen/remove için)' },
+      content: { type: 'string', description: 'LEGACY: subject ile aynı, geriye uyumluluk için tutuluyor' },
+      subject: { type: 'string', description: 'Kısa başlık (zorunlu, add için)' },
+      description: { type: 'string', description: 'Uzun açıklama (opsiyonel)' },
+      activeForm: { type: 'string', description: 'Devam ederken gösterilen form (örn: "Testleri çalıştırıyor")' },
+      status: { type: 'string', enum: ['pending', 'in_progress', 'completed', 'done', 'deleted'] },
+      priority: { type: 'string', enum: ['low', 'medium', 'high'] },
+      owner: { type: 'string', description: 'Atanan agent/kullanıcı adı' },
+      blockedBy: { type: 'array', items: { type: 'string' }, description: 'Bu göreve önce tamamlanması gerekenler' },
+      blocks: { type: 'array', items: { type: 'string' }, description: 'Bu görev tamamlanmadan başlayamayacaklar (ters yönlü blockedBy)' },
+      addBlockedBy: { type: 'array', items: { type: 'string' }, description: 'update için: mevcut blockedBy listesine ekle' },
+      addBlocks: { type: 'array', items: { type: 'string' }, description: 'update için: mevcut blocks listesine ekle' },
+      metadata: { type: 'object', description: 'Arbitrary key/value notlar (update için: null ile sil)' },
     },
   },
-  async execute(params) {
-    return await todoAction(params);
-  },
-};
+  async execute(params) { return todoAction(params); },
+  _internals: { todoAction, _normalizeTodo, _isBlocked, _genId, TODO_FILE },
+};