@hncode/hncode 0.1.11 → 0.3.0

package/src/tools/edit.js

@@ -18,19 +18,76 @@ export const spec = {
     type: 'object',
     properties: {
       path: { type: 'string', description: 'Path to the file to edit.' },
-      old_string: { type: 'string', description: 'Exact text to replace, including whitespace and newlines.' },
-      new_string: { type: 'string', description: 'Replacement text.' },
+      old_string: { type: 'string', description: 'Exact text to replace, including whitespace and newlines. Omit when using start_line/end_line.' },
+      new_string: { type: 'string', description: 'Replacement text for old_string.' },
       replace_all: { type: 'boolean', default: false, description: 'Replace all occurrences of old_string.' },
+      start_line: { type: 'integer', minimum: 1, description: '1-based first line to replace (requires end_line and new_content).' },
+      end_line: { type: 'integer', minimum: 1, description: '1-based last line to replace (inclusive; requires start_line).' },
+      new_content: { type: 'string', description: 'Replacement text for the line range [start_line, end_line]. Requires start_line and end_line.' },
     },
-    required: ['path', 'old_string', 'new_string'],
+    // Either exact-substring mode (old_string+new_string) OR line-range mode.
+    anyOf: [
+      { required: ['path', 'old_string', 'new_string'] },
+      { required: ['path', 'start_line', 'end_line', 'new_content'] },
+    ],
   },
   async execute(args, ctx) {
     let p;
     try { p = resolvePath(args.path, ctx); } catch (e) { return e.message; }
     let content;
     try { content = fs.readFileSync(p, 'utf8'); } catch (e) { return `Error reading ${args.path}: ${e.message}`; }
-    const { old_string, new_string, replace_all = false } = args;
-    if (old_string === '') return `Error: old_string must not be empty.`;
+    const { start_line, end_line, new_content } = args;
+
+    // ---- LINE-RANGE mode ---------------------------------------------------
+    // `start_line`..`end_line` replace the lines at those 1-based positions,
+    // with NO old_string involved at all. This is the path for "change line 12"
+    // where spelling out the exact current text is awkward. It is fully
+    // self-contained: validate -> check the Read cache -> splice -> write ->
+    // refresh the cache -> return.
+    if (start_line != null && end_line != null) {
+      const start = Number(start_line) | 0, end = Number(end_line) | 0;
+      if (start < 1 || end < start) {
+        return `Error: invalid line range ${start_line}-${end_line} (expected 1-based, start <= end).`;
+      }
+      const eol = content.includes('\r\n') ? '\r\n' : '\n';
+      const lines = content.split(/\r\n|\r|\n/);
+      if (end > lines.length) {
+        return `Error: end_line ${end_line} exceeds file length (${lines.length} lines).`;
+      }
+      // STALENESS: the range must sit inside a region this turn actually Read and
+      // that still matches. Same guarantee as the substring path, checked here
+      // directly (no old_string to search for).
+      const stale = checkStaleRange(p, lines, start, end, ctx);
+      if (stale) return stale;
+
+      const inserted = normalizeText(new_content).split('\n');
+      // The lines being REPLACED, captured before the splice. The TUI renders an
+      // Edit's diff from the tool ARGUMENTS, and line-range mode has no
+      // `old_string` to diff against — so without reporting them here the edit
+      // drew NO diff at all (no +/- rows, no +N/-N counts). Reporting them lets
+      // the caller diff `old_content` -> `new_content`.
+      const replacedText = lines.slice(start - 1, end).join('\n');
+      const out = [...lines.slice(0, start - 1), ...inserted, ...lines.slice(end)];
+      const normUpdated = out.join('\n');
+      const updated = eol === '\r\n' ? normUpdated.split('\n').join('\r\n') : normUpdated;
+      try {
+        ensureDir(p);
+        fs.writeFileSync(p, updated, 'utf8');
+      } catch (e) { return `Error writing ${args.path}: ${e.message}`; }
+      refreshReadPool(p, normUpdated, { start, end: start + inserted.length - 1 }, ctx);
+      const removed = end - start + 1;
+      // Publish the diff for the UI. The Edit line is drawn from these, so a
+      // line-range edit shows the same +/- rows and +N/-N counts as a substring
+      // edit instead of nothing. `ctx.lastEditDiff` is consumed (and cleared) by
+      // the agent loop right after this tool returns.
+      if (ctx) ctx.lastEditDiff = { old: replacedText, new: normalizeText(new_content), startLine: start };
+      return `Edited ${args.path}: replaced lines ${start}-${end} (${removed} line${removed === 1 ? '' : 's'}) with ${inserted.length} line${inserted.length === 1 ? '' : 's'}.`;
+    }
+
+
+    // ---- SUBSTRING mode (old_string -> new_string) --------------------------
+    let { old_string, new_string, replace_all = false } = args;
+    if (old_string === '' || old_string == null) return `Error: old_string must not be empty.`;
 
     // --- Newline normalization (Windows CRLF) ---
     // The Read tool normalizes \r\n -> \n, so an agent builds old_string/new_string
@@ -96,10 +153,20 @@ export const spec = {
       }
     }
     const occurrences = replace_all ? count : 1;
+    // Publish the diff for the UI (same contract as the line-range path above).
+    if (ctx) {
+      const startLine = (() => {
+        const at = normContent.split('\n').indexOf(String(normOld).split('\n')[0]);
+        return at >= 0 ? at + 1 : 1;
+      })();
+      ctx.lastEditDiff = { old: normalizeText(old_string), new: normalizeText(new_string), startLine };
+    }
     return `Edited ${args.path}: replaced ${occurrences} occurrence(s).`;
   },
 };
 
+// Returns an error message when the edit is stale, else null (safe to edit).
+
 // Returns an error message when the edit is stale, else null (safe to edit).
 function checkStale(p, normContent, normOld, ctx) {
   if (!ctx || !ctx.readPool) return null; // no Read happened; nothing to verify
@@ -135,4 +202,48 @@ function checkStale(p, normContent, normOld, ctx) {
   // (3) The file changed on disk since it was Read and the edit target is not in
   //     an intact Read region. Reject so a stale snippet cannot corrupt the file.
   return `Edit rejected: ${p} changed since it was Read (the edited region is not in an intact Read snapshot). Re-run Read to get the current content, then Edit.`;
-}
+}
+// ---- helpers for the line-range path ---------------------------------------
+
+// Same guarantee as checkStale, but for an explicit [start, end] line range:
+// every line in the range must sit inside a region that was Read this turn and
+// whose content still matches. Returns an error string, or null when safe.
+function checkStaleRange(p, curLines, start, end, ctx) {
+  if (!ctx || !ctx.readPool) return null; // no Read happened; nothing to verify
+  const entry = ctx.readPool.get(p);
+  if (!entry) return null;                // never Read this turn; allow
+
+  const normContent = curLines.join('\n');
+  const curFileHash = hashStr(normContent);
+
+  // A region covers the range when it fully contains it AND still hashes the
+  // same as when it was Read.
+  const covered = entry.regions.some(
+    (r) => start >= r.start && end <= r.end && hashLines(curLines, r.start, r.end) === r.hash,
+  );
+  if (covered) return null;
+
+  if (curFileHash === entry.fileHash) {
+    // No "(read so far: …)" listing: the range is what the model must act on, and
+    // echoing the regions it HAS read only invited it to reason about them instead
+    // of re-reading the target lines.
+    return `Edit rejected: lines ${start}-${end} were not read in ${p}. Read the target lines first (Read with line_offset / n_lines), then Edit.`;
+  }
+  return `Edit rejected: ${p} changed since it was Read (lines ${start}-${end} are not in an intact Read snapshot). Re-run Read to get the current content, then Edit.`;
+}
+
+// Refresh the region cache after a successful edit: drop regions that no longer
+// match the NEW content, and record the freshly-written span. Mirrors the
+// re-arm block used by the substring path.
+function refreshReadPool(p, normUpdated, written, ctx) {
+  if (!ctx || !ctx.readPool) return;
+  const entry = ctx.readPool.get(p);
+  if (!entry) return;
+  const newLines = normUpdated.split('\n');
+  entry.fileHash = hashStr(normUpdated);
+  entry.lines = newLines.length;
+  const kept = entry.regions.filter((r) => hashLines(newLines, r.start, r.end) === r.hash);
+  kept.push({ start: written.start, end: Math.min(newLines.length, Math.max(written.start, written.end)), hash: hashLines(newLines, written.start, Math.min(newLines.length, Math.max(written.start, written.end))) });
+  entry.regions = kept;
+  try { const st = fs.statSync(p); entry.size = st.size; entry.mtimeMs = st.mtimeMs; } catch {}
+}

package/src/tools/glob.js

@@ -22,7 +22,13 @@ export const spec = {
     required: ['pattern'],
   },
   async execute(args, ctx) {
-    const fromDir = args.path ? args.path : '.';
+    // `pattern` is required, but the model can still omit it. Return an error
+    // string like every other tool instead of throwing — an uncaught throw here
+    // aborts the whole turn.
+    if (typeof args.pattern !== 'string' || !args.pattern.trim()) {
+      return 'Error: `pattern` is required (e.g. "src/**/*.ts").';
+    }
+    const fromDir = typeof args.path === 'string' && args.path ? args.path : '.';
     const p = normalizeInput(fromDir);
     let base;
     try { base = path.resolve(ctx.cwd || ctx.workspace, p); } catch (e) { return `Error: ${e.message}`; }
@@ -32,6 +38,7 @@ export const spec = {
     const alts = expandBraces(args.pattern);
     const re = new RegExp('^(?:' + alts.map((a) => globRegex(a).source.slice(1, -1)).join('|') + ')$');
 
+
     const files = walkFiles(base, { includeIgnored: !!args.include_ignored, includeDirs: false });
     const matches = [];
     for (const abs of files) {

package/src/tools/index.js

@@ -12,6 +12,9 @@ import * as fetchUrlMod from './fetch-url.js';
 import * as webSearchMod from './web-search.js';
 import * as readMediaFileMod from './read-media-file.js';
 import * as fileLinesMod from './file-lines.js';
+import * as askUserQuestionMod from './ask-user-question.js';
+import { spec as agentSpec } from './agent.js';
+import { spec as agentSwarmSpec } from './agent-swarm.js';
 import { TaskListSpec, TaskOutputSpec, TaskStopSpec, TaskWaitSpec } from './tasks.js';
 import { pluginTools } from '../plugin.js';
 
@@ -28,6 +31,9 @@ const builtinTools = [
   webSearchMod.spec,
   readMediaFileMod.spec,
   fileLinesMod.spec,
+  askUserQuestionMod.spec,
+  agentSpec,
+  agentSwarmSpec,
   TaskListSpec,
   TaskOutputSpec,
   TaskStopSpec,

package/src/tools/tasks.js

@@ -1,126 +1,140 @@
-// TaskList / TaskOutput / TaskStop — manage background Bash tasks spawned with
-// run_in_background.
-
-import cp from 'node:child_process';
-
-export const TaskListSpec = {
-  name: 'TaskList',
-  description: 'List background tasks (from Bash run_in_background). Reports id, status, description.',
-  parameters: { type: 'object', properties: {}, required: [] },
-  async execute(_args, ctx) {
-    const tasks = Object.values(ctx.tasks || {}).sort((a, b) => b.start - a.start);
-    if (tasks.length === 0) return 'No background tasks.';
-    return tasks.map((t) => `#${t.id} [${t.status}] pid=${t.pid} ${t.description || t.command}`).join('\n');
-  },
-};
-
-export const TaskOutputSpec = {
-  name: 'TaskOutput',
-  description: 'Get the output of a background task (Bash run_in_background) by task_id. head_limit caps the lines returned.',
-  parameters: {
-    type: 'object',
-    properties: {
-      task_id: { type: 'string', description: 'Task id returned when the task was started.' },
-      head_limit: { type: 'integer', minimum: 0, description: 'Max output lines returned.' },
-    },
-    required: ['task_id'],
-  },
-  async execute(args, ctx) {
-    const t = (ctx.tasks || {})[args.task_id];
-    if (!t) return `No such task: ${args.task_id}`;
-    const lines = t.output ? t.output.split('\n').filter((l) => l.length > 0) : [];
-    const capped = args.head_limit ? lines.slice(0, args.head_limit) : lines;
-    const tail = lines.length > (capped.length);
-    let out = `#${t.id} [${t.status}] (pid ${t.pid})\n${capped.join('\n')}`;
-    if (tail) out += `\n... [${lines.length - capped.length} more lines; use head_limit]`;
-    return out;
-  },
-};
-
-export const TaskStopSpec = {
-  name: 'TaskStop',
-  description: 'Stop a running background task (Bash run_in_background) by task_id. Use only when the task must be cancelled.',
-  parameters: {
-    type: 'object',
-    properties: {
-      task_id: { type: 'string', description: 'Background task id to stop.' },
-      reason: { type: 'string', description: 'Short reason recorded on stop.' },
-    },
-    required: ['task_id'],
-  },
-  async execute(args, ctx) {
-    const t = (ctx.tasks || {})[args.task_id];
-    if (!t) return `No such task: ${args.task_id}`;
-    if (t.status !== 'running') return `Task ${t.id} is not running (status: ${t.status}).`;
-    const reason = args.reason || 'Stopped by TaskStop';
-    try {
-      if (process.platform === 'win32' && t.pid) {
-        try { cp.spawnSync('taskkill', ['/pid', String(t.pid), '/t', '/f'], { stdio: 'ignore' }); } catch {}
-      } else if (t.pid) {
-        try { process.kill(t.pid, 'SIGTERM'); } catch {}
-      }
-    } catch (e) {
-      return `Failed to stop ${t.id}: ${e.message}`;
-    }
-    t.status = 'stopped';
-    t.stopReason = reason;
-    t.end = Date.now();
-    return `Stopped task ${t.id}. reason: ${reason}`;
-  },
-};
-
-// WaitFor — block until a background task finishes (or the timeout elapses).
-// Mirrors kimi-code's task-wait: a timeout is not an error; the result lists
-// the tasks still running so the caller can wait again.
-export const TaskWaitSpec = {
-  name: 'TaskWait',
-  description: 'Wait for background tasks (Bash run_in_background) to finish, timeout in seconds (1-600). With task_id, waits for that task; without it, returns when any running task finishes. A timeout is not an error; still-running tasks are listed, so you may call it again.',
-  parameters: {
-    type: 'object',
-    properties: {
-      timeout: { type: 'integer', minimum: 1, maximum: 600, description: 'Max seconds to wait (1-600).' },
-      task_id: { type: 'string', description: 'Task id to wait for; omit to wait for any running task.' },
-    },
-    required: ['timeout'],
-  },
-  async execute(args, ctx) {
-    const tasks = ctx.tasks || {};
-    const target = args.task_id ? tasks[args.task_id] : null;
-    if (args.task_id && !target) return `No such task: ${args.task_id}`;
-    const secs = Math.max(1, Math.min(600, Number(args.timeout) || 1));
-    const deadline = Date.now() + secs * 1000;
-    const signal = ctx && ctx.signal;
-
-    const isDone = (t) => t && t.status !== 'running';
-    const anyRunning = () => Object.values(tasks).some((t) => t.status === 'running');
-
-    // Nothing to wait for at call time.
-    if (args.task_id) {
-      if (isDone(target)) return `Task ${target.id} already ${target.status}${target.code !== undefined ? ` (exit ${target.code})` : ''}.`;
-    } else if (!anyRunning()) {
-      return 'No background tasks are running.';
-    }
-
-    await new Promise((resolve) => {
-      const tick = setInterval(() => {
-        const done = args.task_id ? isDone(target) : !anyRunning();
-        if (done || Date.now() >= deadline || (signal && signal.aborted)) {
-          clearInterval(tick);
-          resolve();
-        }
-      }, 100);
-    });
-
-    if (signal && signal.aborted) return 'Interrupted by user';
-    const still = Object.values(tasks).filter((t) => t.status === 'running');
-    if (args.task_id) {
-      if (isDone(target)) {
-        return `Task ${target.id} finished: ${target.status}${target.code !== undefined ? ` (exit ${target.code})` : ''}${target.stopReason ? ` — ${target.stopReason}` : ''}.`;
-      }
-      return `Task ${target.id} still running after ${secs}s.`;
-    }
-    if (!still.length) return 'All background tasks have finished.';
-    const list = still.map((t) => `#${t.id} ${t.description || t.command}`).join('; ');
-    return `Timeout after ${secs}s; still running: ${list}`;
-  },
-};
+// TaskList / TaskOutput / TaskStop / TaskWait — manage background tasks spawned
+// by Bash (run_in_background) and Agent (run_in_background). The task records
+// live in the shared registry (src/agent-task.js), so the CLI tools and the
+// /tasks panel read exactly the same data.
+
+import cp from 'node:child_process';
+import { isTerminal, settleTask, STATUS_LABEL } from '../agent-task.js';
+
+function taskLine(t) {
+  const extra = t.stopReason ? ` (${t.stopReason})` : '';
+  const label = STATUS_LABEL[t.status] || t.status;
+  const what = t.kind === 'process' ? (t.description || t.command) : t.description;
+  return `#${t.taskId} [${label}${extra}] pid=${t.pid || '-'} ${what}`;
+}
+
+export const TaskListSpec = {
+  name: 'TaskList',
+  description: 'List background tasks (from Bash or Agent run_in_background). Reports task id, status, description.',
+  parameters: { type: 'object', properties: {}, required: [] },
+  async execute(_args, ctx) {
+    const tasks = Object.values(ctx.tasks || {}).sort((a, b) => b.startedAt - a.startedAt);
+    if (tasks.length === 0) return 'No background tasks.';
+    return tasks.map(taskLine).join('\n');
+  },
+};
+
+export const TaskOutputSpec = {
+  name: 'TaskOutput',
+  description: 'Get the output of a background task by task_id. head_limit caps the lines returned.',
+  parameters: {
+    type: 'object',
+    properties: {
+      task_id: { type: 'string', description: 'Task id returned when the task was started.' },
+      head_limit: { type: 'integer', minimum: 0, description: 'Max output lines returned.' },
+    },
+    required: ['task_id'],
+  },
+  async execute(args, ctx) {
+    const t = (ctx.tasks || {})[args.task_id];
+    if (!t) return `No such task: ${args.task_id}`;
+    const text = t.output || '';
+    const lines = text ? text.split('\n').filter((l) => l.length > 0) : [];
+    const capped = args.head_limit ? lines.slice(0, args.head_limit) : lines;
+    const tail = lines.length > capped.length;
+    const label = STATUS_LABEL[t.status] || t.status;
+    let out = `#${t.taskId} [${label}] (pid ${t.pid || '-'})\n${capped.join('\n')}`;
+    if (tail) out += `\n... [${lines.length - capped.length} more lines; use head_limit]`;
+    return out;
+  },
+};
+
+export const TaskStopSpec = {
+  name: 'TaskStop',
+  description: 'Stop a running background task by task_id. Use only when the task must be cancelled.',
+  parameters: {
+    type: 'object',
+    properties: {
+      task_id: { type: 'string', description: 'Background task id to stop.' },
+      reason: { type: 'string', description: 'Short reason recorded on stop.' },
+    },
+    required: ['task_id'],
+  },
+  async execute(args, ctx) {
+    const t = (ctx.tasks || {})[args.task_id];
+    if (!t) return `No such task: ${args.task_id}`;
+    if (isTerminal(t.status)) return `Task ${t.taskId} already ${STATUS_LABEL[t.status] || t.status}.`;
+    const reason = args.reason || 'Stopped by TaskStop';
+    try {
+      // An agent task aborts through its controller; a process is killed.
+      if (t.kind === 'agent' && typeof t._abort === 'function') {
+        t._abort();
+      } else if (t.pid) {
+        if (process.platform === 'win32') {
+          try { cp.spawnSync('taskkill', ['/pid', String(t.pid), '/t', '/f'], { stdio: 'ignore' }); } catch {}
+        } else {
+          try { process.kill(t.pid, 'SIGTERM'); } catch {}
+        }
+      }
+    } catch (e) {
+      return `Failed to stop ${t.taskId}: ${e.message}`;
+    }
+    // 'killed' — a deliberate stop, distinct from a failure (kimi's vocabulary).
+    settleTask(t, 'killed', { stopReason: reason });
+    return `Stopped task ${t.taskId}. reason: ${reason}`;
+  },
+};
+
+// Wait for background tasks to finish. A timeout is not an error; the result
+// lists the tasks still running so the caller can wait again.
+export const TaskWaitSpec = {
+  name: 'TaskWait',
+  description: 'Wait for background tasks to finish, timeout in seconds (1-600). With task_id, waits for that task; without it, returns when any running task finishes. A timeout is not an error; still-running tasks are listed, so you may call it again.',
+  parameters: {
+    type: 'object',
+    properties: {
+      timeout: { type: 'integer', minimum: 1, maximum: 600, description: 'Max seconds to wait (1-600).' },
+      task_id: { type: 'string', description: 'Task id to wait for; omit to wait for any running task.' },
+    },
+    required: ['timeout'],
+  },
+  async execute(args, ctx) {
+    const tasks = ctx.tasks || {};
+    const target = args.task_id ? tasks[args.task_id] : null;
+    if (args.task_id && !target) return `No such task: ${args.task_id}`;
+    const secs = Math.max(1, Math.min(600, Number(args.timeout) || 1));
+    const deadline = Date.now() + secs * 1000;
+    const signal = ctx && ctx.signal;
+
+    const isDone = (t) => t && isTerminal(t.status);
+    const anyRunning = () => Object.values(tasks).some((t) => t.status === 'running');
+
+    if (args.task_id) {
+      if (isDone(target)) return `Task ${target.taskId} already ${STATUS_LABEL[target.status] || target.status}${target.exitCode != null ? ` (exit ${target.exitCode})` : ''}.`;
+    } else if (!anyRunning()) {
+      return 'No background tasks are running.';
+    }
+
+    await new Promise((resolve) => {
+      const tick = setInterval(() => {
+        const done = args.task_id ? isDone(target) : !anyRunning();
+        if (done || Date.now() >= deadline || (signal && signal.aborted)) {
+          clearInterval(tick);
+          resolve();
+        }
+      }, 100);
+    });
+
+    if (signal && signal.aborted) return 'Interrupted by user';
+    const still = Object.values(tasks).filter((t) => t.status === 'running');
+    if (args.task_id) {
+      if (isDone(target)) {
+        return `Task ${target.taskId} finished: ${STATUS_LABEL[target.status] || target.status}${target.exitCode != null ? ` (exit ${target.exitCode})` : ''}${target.stopReason ? ` — ${target.stopReason}` : ''}.`;
+      }
+      return `Task ${target.taskId} still running after ${secs}s.`;
+    }
+    if (!still.length) return 'All background tasks have finished.';
+    const list = still.map((t) => `#${t.taskId} ${t.description || t.command || ''}`).join('; ');
+    return `Timeout after ${secs}s; still running: ${list}`;
+  },
+};

package/src/tools/todo.js

@@ -3,7 +3,21 @@
 
 export const spec = {
   name: 'TodoList',
-  description: 'Track multi-step work. Pass the COMPLETE list; it replaces the current one. Items: title + status (pending | in_progress | done).',
+  description: `Track multi-step work. Pass the COMPLETE list; it replaces the current one. Items: title + status (pending | in_progress | done).
+
+When to use it:
+- Non-trivial work with several ordered steps, or a request that asks for more than one thing.
+- NOT for a straightforward task you can finish in a step or two, and never as a single-item list.
+
+Maintaining the list:
+- Keep exactly ONE item in_progress at a time until everything is done.
+- Never move an item straight from pending to done: set it to in_progress first, so the list reflects
+  what is actually happening. Do not tick off several items in one update after the fact.
+- Step titles are short (5-7 words), one line each.
+- Update the list as you go, before starting the next step, not in a batch at the end.
+- If your understanding changes, replace the whole list with the corrected one and say why.
+- Finish with every item done, or explicitly say which you abandoned and why. Do not leave the list stale.
+- Do not repeat the list back to the user after updating it — the UI already shows it.`,
   parameters: {
     type: 'object',
     properties: {
@@ -23,7 +37,20 @@ export const spec = {
     required: ['todos'],
   },
   async execute(args, ctx) {
-    ctx.todoState = args.todos.map((t) => ({ title: String(t.title), status: t.status || 'pending' }));
+    // `todos` is required, but a missing or mistyped value must not throw: an
+    // uncaught error here aborts the whole turn. Return a message the model can
+    // act on, like every other tool.
+    if (!Array.isArray(args.todos)) {
+      return 'Error: `todos` must be an array of { title, status }.';
+    }
+    const VALID = ['pending', 'in_progress', 'done'];
+    const badStatus = args.todos.find((t) => t && t.status != null && !VALID.includes(t.status));
+    if (badStatus) {
+      return `Error: invalid status ${JSON.stringify(badStatus.status)}; use one of ${VALID.join(' | ')}.`;
+    }
+    const empty = args.todos.find((t) => !t || typeof t.title !== 'string' || !t.title.trim());
+    if (empty) return 'Error: every todo needs a non-empty `title`.';
+    ctx.todoState = args.todos.map((t) => ({ title: String(t.title).trim(), status: t.status || 'pending' }));
     return render(ctx.todoState);
   },
 };