@getpipher/armory-todo 0.3.1 → 0.5.0

package/extensions/todo.ts

@@ -40,8 +40,10 @@ import { hardPrune } from "../src/hard-prune";
 import { TodoPanel } from "../src/panel";
 import { autoPruneOnSessionStart } from "../src/auto-prune";
 import { loadConfig } from "../src/config";
+import { projectsOverview } from "../src/projects";
+import { renameProject } from "../src/registry";
 
-const ACTIONS = ["list", "add", "update", "get", "complete", "delete", "clear", "park", "prune", "restore", "health"] as const;
+const ACTIONS = ["list", "add", "update", "get", "complete", "delete", "clear", "park", "prune", "restore", "health", "projects", "project_rename"] as const;
 
 function fmt(t: ReturnType<typeof listTodos>[number]): string {
   const tag = t.project ? ` (${t.project})` : "";
@@ -131,7 +133,7 @@ export default function (pi: ExtensionAPI) {
       "Never put secrets in a TODO — the text reaches the model provider.",
     promptSnippet: "Read/update the global cross-session TODO list (active / parked / archive) + bloat health",
     promptGuidelines: [
-      "Use todo (action:'add', title, notes?, project?, tags?, priority?, source?) when the user says 'put this in our TODO'. title max 120 chars (one-line summary); put long detail in notes.",
+      "Use todo (action:'add', title, notes?, project?, tags?, priority?, source?) when the user says 'put this in our TODO'. title max 120 chars (one-line summary); put long detail in notes (capped at health.maxNotesBytes, default 8KB — oversize is rejected at write). Adds are BLOCKED if the target project is at its per-project maxOpen cap (the slot you set via the Projects tab); close/park one or raise maxOpen first.",
       "Use todo (action:'get', id) to read a todo's full notes before acting on it (the bullet marker in lists means notes exist).",
       "Use todo (action:'update', id, title?, notes?, project?, tags?, priority?, status?) to edit; notes empty string clears.",
       "Use todo (action:'list') when the user asks 'show me the TODO' / 'what's pending' (text filter searches title+notes).",
@@ -143,6 +145,8 @@ export default function (pi: ExtensionAPI) {
       "Use todo (action:'list', archived:true) to query the archive; bare call returns a summary, add a filter (project/text/since) for specific items.",
       "Use todo (action:'health') to check bloat across all boxes (counts + flags + suggestions). Run when the user asks about hygiene/bloat or before any hard-prune.",
       "Use todo (action:'prune', hard:true, confirm:true, box?, olderThan?) for PERMANENT deletion (the only irreversible action). ALWAYS run health first, show the user the report + the exact proposed command, and wait for an explicit yes before passing confirm:true. Never hard-prune without explicit user confirmation.",
+      "Use todo (action:'projects') for a per-project scope overview (open/in_progress/parked/done counts + maxOpen + OVER/?typo markers). Run when the user asks 'which projects have open work' or to see backlog shape by project.",
+      "Use todo (action:'project_rename', oldName, newName) to rename or merge a project (rewrites live + archive + registry). Use it to fix typo'd project strings (e.g. getpither → getpipher). Rename onto an existing name merges (consolidates the old project into the new). Per-project maxOpen caps are ENFORCED (block-on-add); they also drive a PROJECT_OVER health flag when breached.",
     ],
     parameters: Type.Object({
       action: StringEnum(ACTIONS),
@@ -171,6 +175,9 @@ export default function (pi: ExtensionAPI) {
       confirm: Type.Optional(Type.Boolean({ description: "hard-prune: must be true to execute. Always surface the health report + proposed command and wait for explicit user confirmation first." })),
       box: Type.Optional(StringEnum(["archive", "active", "parked"] as const, { description: "hard-prune: which box to target (default archive)" })),
       olderThan: Type.Optional(Type.Number({ description: "hard-prune: delete items older than this many days (by closedAt for archive, updatedAt for active/parked)" })),
+      // project actions (v0.4.0)
+      oldName: Type.Optional(Type.String({ description: "project_rename: current project name" })),
+      newName: Type.Optional(Type.String({ description: "project_rename: new project name (merge if it already exists)" })),
     }),
     async execute(_toolCallId, params) {
       try {
@@ -296,13 +303,22 @@ export default function (pi: ExtensionAPI) {
           }
           case "health": {
             const report = healthReport();
+            const projLines = report.projects.length
+              ? [`projects:`, ...report.projects.map((p) => {
+                  const cap = p.maxOpen !== null ? ` [max:${p.maxOpen}]` : "";
+                  const flags = [p.over && "OVER", p.large && "LARGE", p.stale && "STALE", p.typo && "TYPO"].filter(Boolean).join(" ");
+                  return `  ${p.name}  ${p.open} open${cap}${flags ? ` ${flags}` : ""}`;
+                })]
+              : [];
             const lines = [
               `## TODO Health Report`,
               `active:  ${report.active.open} open + ${report.active.in_progress} in_progress (${report.active.stale_30d} stale)`,
               `parked:  ${report.parked.count} (${report.parked.stale_60d} stale)`,
               `archive: ${report.archive.count} (${report.archive.older_180d} old)`,
               `notes:   ${report.notesBytes.total}B total · max ${report.notesBytes.max}B · avg ${report.notesBytes.avg}B`,
+              `(no project): ${report.noProject.open} open`,
               report.flags.length ? `flags: ${report.flags.join(", ")}` : "flags: (none — healthy)",
+              ...projLines,
               ...report.suggestions.map((s) => `  → ${s}`),
             ];
             return { content: [{ type: "text" as const, text: lines.join("\n") }] };
@@ -316,6 +332,25 @@ export default function (pi: ExtensionAPI) {
             const n = clearTodos((params.status as any) ?? "done");
             return { content: [{ type: "text" as const, text: `Cleared ${n} '${params.status ?? "done"}' TODOs.` }] };
           }
+          case "projects": {
+            const o = projectsOverview();
+            const rows = o.rows.map((r) => {
+              const cap = r.maxOpen !== null ? ` [max:${r.maxOpen}]` : "";
+              const over = r.over ? " OVER" : "";
+              const typo = r.typo ? " ?typo" : "";
+              return `  ${r.name}  ${r.open}o/${r.in_progress}i/${r.parked}p/${r.done}d (total ${r.total})${cap}${over}${typo}`;
+            });
+            const np = `(no project): ${o.noProject.count} total · ${o.noProject.open} open`;
+            const text = rows.length ? `Projects (${o.rows.length}):\n${rows.join("\n")}\n${np}` : `Projects: (none)\n${np}`;
+            return { content: [{ type: "text" as const, text }] };
+          }
+          case "project_rename": {
+            if (!params.oldName || !params.newName) {
+              return { content: [{ type: "text" as const, text: "Error: `oldName` and `newName` are required for project_rename." }] };
+            }
+            const r = renameProject(params.oldName, params.newName);
+            return { content: [{ type: "text" as const, text: `Renamed ${params.oldName} → ${r.newName}: ${r.liveRenamed} live + ${r.archivedRenamed} archived${r.merged ? " (merged)" : ""}` }] };
+          }
           default:
             return { content: [{ type: "text" as const, text: `Unknown action: ${params.action}` }] };
         }
@@ -331,7 +366,7 @@ export default function (pi: ExtensionAPI) {
       "Global cross-session TODO list. " +
       "/todo / /todo all / /todo add <title> / /todo done <id> / /todo rm <id> / " +
       "/todo park <id> / /todo restore <id> / /todo prune [--all|--hard --box <b> --older-than <d>] / " +
-      "/todo archive [project:X|text:Y] / /todo finished / /todo health / /todo clean / /todo path",
+      "/todo archive [project:X|text:Y] / /todo finished / /todo projects / /todo health / /todo clean / /todo path",
     handler: async (args, ctx) => {
       const a = (args ?? "").trim();
       const [sub, ...rest] = a.split(/\s+/);
@@ -410,13 +445,22 @@ export default function (pi: ExtensionAPI) {
         }
         if (sub === "health") {
           const report = healthReport();
+          const projLines = report.projects.length
+            ? [`  projects:`, ...report.projects.map((p) => {
+                const cap = p.maxOpen !== null ? ` [max:${p.maxOpen}]` : "";
+                const flags = [p.over && "OVER", p.large && "LARGE", p.stale && "STALE", p.typo && "TYPO"].filter(Boolean).join(" ");
+                return `    ${p.name}  ${p.open} open${cap}${flags ? ` ${flags}` : ""}`;
+              })]
+            : [];
           const lines = [
             `TODO Health:`,
             `  active:  ${report.active.open} open + ${report.active.in_progress} in_progress (${report.active.stale_30d} stale)`,
             `  parked:  ${report.parked.count} (${report.parked.stale_60d} stale)`,
             `  archive: ${report.archive.count} (${report.archive.older_180d} old)`,
             `  notes:   ${report.notesBytes.total}B total · max ${report.notesBytes.max}B · avg ${report.notesBytes.avg}B`,
+            `  (no project): ${report.noProject.open} open`,
             report.flags.length ? `  ⚠ ${report.flags.join(", ")}` : "  ✅ healthy",
+            ...projLines,
             ...report.suggestions.map((s) => `  → ${s}`),
           ];
           if (ctx.hasUI) ctx.ui.notify(lines.join("\n"), "info");
@@ -463,6 +507,19 @@ export default function (pi: ExtensionAPI) {
           if (ctx.hasUI) ctx.ui.notify(`store: ${getStorePath()}`, "info");
           return;
         }
+        if (sub === "projects") {
+          const o = projectsOverview();
+          const rows = o.rows.map((r) => {
+            const cap = r.maxOpen !== null ? ` [max:${r.maxOpen}]` : "";
+            const over = r.over ? " OVER" : "";
+            const typo = r.typo ? " ?typo" : "";
+            return `  ${r.name}  ${r.open}o/${r.in_progress}i/${r.parked}p/${r.done}d (total ${r.total})${cap}${over}${typo}`;
+          });
+          const np = `(no project): ${o.noProject.count} total · ${o.noProject.open} open`;
+          const msg = rows.length ? `Projects (${o.rows.length}):\n${rows.join("\n")}\n${np}` : `Projects: (none)\n${np}`;
+          if (ctx.hasUI) ctx.ui.notify(msg, "info");
+          return;
+        }
         // default: open the interactive panel (TUI) or list open (non-TUI)
         if (ctx.mode === "tui") {
           await ctx.ui.custom<boolean>((_tui, theme, _kb, done) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpipher/armory-todo",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "Global, cross-session TODO for pi — persists across all sessions and is auto-injected into every prompt. The disk-backed counterpart to branch-scoped pi todo extensions.",
   "keywords": [
     "pi-package",
@@ -35,7 +35,7 @@
     ]
   },
   "scripts": {
-    "test": "for t in todo-store todo-title-notes todo-archive todo-config todo-migrate todo-health todo-hard-prune todo-auto-prune panel-data; do node test/$t.test.mts || exit 1; done"
+    "test": "for t in todo-store todo-title-notes todo-archive todo-config todo-migrate todo-health todo-hard-prune todo-auto-prune registry projects panel-data todo-caps; do node test/$t.test.mts || exit 1; done"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",

package/src/caps.ts

@@ -0,0 +1,71 @@
+// Caps enforcement primitives for armory-todo (v0.5.0). Pure — no disk I/O,
+// no config/registry loads. Callers (addTodo/updateTodo/renderOpenBlock) load
+// state and pass it in, so these are unit-testable in isolation.
+//
+// Two caps:
+//   - notes  : per-todo byte ceiling (health.maxNotesBytes), hard-reject at write.
+//   - project: per-project open-count ceiling (registry maxOpen), hard-reject
+//              on add + project-move (only for open/in_progress todos).
+// Both throw TodoError BEFORE any store mutation (callers ensure atomicity).
+//
+// Circular import note: caps.ts imports TodoError/Todo (types) from
+// todo-store.ts; todo-store.ts imports the cap functions. Safe — no module
+// touches another's exports at top level; all usage is inside functions, so
+// both are fully loaded by call-time.
+
+import { TodoError, type Todo } from "./todo-store.ts";
+import type { ProjectRegistry } from "./registry.ts";
+
+/** Human-readable byte size for error messages: 512 -> "512B", 2048 -> "2.0KB". */
+function formatBytes(n: number): string {
+  if (n < 1024) return `${n}B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)}KB`;
+  return `${(n / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+/** Throw if notes exceeds the byte cap. Byte-length (not char-length): notes
+ *  can hold Unicode ("é" = 2 bytes UTF-8). A maxBytes of 0 means "no notes
+ *  allowed" (only empty notes pass). Negative maxBytes rejects everything
+ *  (treated as a misconfig; config load clamps negative/NaN to the default). */
+export function checkNotesCap(notes: string, maxBytes: number): void {
+  const bytes = Buffer.byteLength(notes, "utf8");
+  if (bytes > maxBytes) {
+    throw new TodoError(
+      `notes ${formatBytes(bytes)} > max ${formatBytes(maxBytes)} (maxNotesBytes ${maxBytes}) — trim the detail or split into multiple todos`,
+    );
+  }
+}
+
+export interface ProjectCapInput {
+  project: string;        // target project name (already trimmed by caller)
+  currentOpen: number;     // target's current open count, NOT counting the would-be-added/moved todo
+  maxOpen: number | null;  // from the registry entry; null = uncapped
+}
+
+/** Throw if adding one more open todo to `project` would exceed its cap.
+ *  `maxOpen === null` -> no-op (uncapped). The cap is on the `open` count only
+ *  (matches the PROJECT_OVER health definition; in_progress does not count). */
+export function checkProjectCap({ project, currentOpen, maxOpen }: ProjectCapInput): void {
+  if (maxOpen === null) return;
+  if (currentOpen + 1 > maxOpen) {
+    throw new TodoError(
+      `project '${project}' is at maxOpen ${maxOpen} (${currentOpen} open) — close/park one, or raise maxOpen via the /todo panel (Projects tab -> Set maxOpen), before adding`,
+    );
+  }
+}
+
+export interface OverBudgetProject { name: string; open: number; maxOpen: number; }
+
+/** Projects whose open count exceeds their explicit maxOpen (maxOpen non-null).
+ *  Pure; consumed by renderOpenBlock's over-cap summary. `liveTodos` is the
+ *  full live store array. Open is counted here (status === "open"). Sorted by
+ *  breach depth (open - maxOpen) desc, then name asc. */
+export function overBudgetProjects(liveTodos: Todo[], registry: ProjectRegistry): OverBudgetProject[] {
+  const out: OverBudgetProject[] = [];
+  for (const entry of registry.projects) {
+    if (entry.maxOpen === null) continue;
+    const open = liveTodos.filter((t) => t.project === entry.name && t.status === "open").length;
+    if (open > entry.maxOpen) out.push({ name: entry.name, open, maxOpen: entry.maxOpen });
+  }
+  return out.sort((a, b) => (b.open - b.maxOpen) - (a.open - a.maxOpen) || a.name.localeCompare(b.name));
+}

package/src/config.ts

@@ -24,6 +24,8 @@ export interface HealthConfig {
   parkedStaleDays: number;
   archiveMax: number;
   archiveOldDays: number;
+  perProjectDefaultMax: number;  // v0.4.0: per-project PROJECT_LARGE threshold (advisory)
+  maxNotesBytes: number;         // v0.5.0: per-todo notes byte cap (hard-reject at add/update)
 }
 
 export interface TodoConfig {
@@ -46,6 +48,8 @@ export const DEFAULT_CONFIG: TodoConfig = {
     parkedStaleDays: 60,
     archiveMax: 200,
     archiveOldDays: 180,
+    perProjectDefaultMax: 8,
+    maxNotesBytes: 8192,
   },
 };
 
@@ -68,10 +72,15 @@ export function loadConfig(): TodoConfig {
       throw new Error("invalid config shape");
     }
     // Merge with defaults so new fields get filled in on upgrade.
+    const health = { ...DEFAULT_CONFIG.health, ...parsed.health };
+    if (health.perProjectDefaultMax === undefined) health.perProjectDefaultMax = DEFAULT_CONFIG.health.perProjectDefaultMax;
+    if (health.maxNotesBytes === undefined || typeof health.maxNotesBytes !== "number" || Number.isNaN(health.maxNotesBytes) || health.maxNotesBytes < 0) {
+      health.maxNotesBytes = DEFAULT_CONFIG.health.maxNotesBytes;
+    }
     return {
       version: 1,
       prune: { ...DEFAULT_CONFIG.prune, ...parsed.prune },
-      health: { ...DEFAULT_CONFIG.health, ...parsed.health },
+      health,
     };
   } catch {
     try {

package/src/health.ts

@@ -6,6 +6,8 @@
 import { loadStore } from "./todo-store.ts";
 import { loadArchive } from "./archive.ts";
 import { loadConfig } from "./config.ts";
+import { loadRegistry, reconcileRegistry, saveRegistry, getProjectEntry } from "./registry.ts";
+import { levenshtein } from "./levenshtein.ts";
 
 export interface ActiveHealth {
   open: number;
@@ -26,13 +28,27 @@ export interface ArchiveHealth {
 export interface NotesBytes {
   total: number;
   max: number;
+  maxId: string | null;   // v0.5.0: id of the todo with the largest notes (null if no todos)
   avg: number;
 }
 
 export type HealthFlag =
   | "ACTIVE_LARGE" | "ACTIVE_STALE"
   | "PARKED_LARGE" | "PARKED_STALE"
-  | "ARCHIVE_LARGE" | "ARCHIVE_OLD";
+  | "ARCHIVE_LARGE" | "ARCHIVE_OLD"
+  | "NOTES_OVER"
+  | "PROJECT_OVER" | "PROJECT_TYPO" | "PROJECT_LARGE" | "PROJECT_STALE";
+
+export interface ProjectHealth {
+  name: string;
+  open: number;
+  maxOpen: number | null;
+  over: boolean;
+  typo: boolean;
+  large: boolean;
+  stale: boolean;
+  lastUpdated: string;
+}
 
 export interface HealthReport {
   active: ActiveHealth;
@@ -41,6 +57,8 @@ export interface HealthReport {
   notesBytes: NotesBytes;
   flags: HealthFlag[];
   suggestions: string[];
+  projects: ProjectHealth[];   // only projects with ≥1 flag, sorted open desc
+  noProject: { open: number };  // (no project) open count, for context
 }
 
 function daysAgo(iso: string): number {
@@ -53,6 +71,11 @@ export function healthReport(): HealthReport {
   const live = loadStore();
   const archive = loadArchive();
 
+  // reconcile registry first (lazy sync), persist iff changed
+  const reg = loadRegistry();
+  const { reg: synced, changed } = reconcileRegistry(reg, live.todos, archive.todos);
+  if (changed) saveRegistry(synced);
+
   const openTodos = live.todos.filter((t) => t.status === "open");
   const ipTodos = live.todos.filter((t) => t.status === "in_progress");
   const parkedTodos = live.todos.filter((t) => t.status === "parked");
@@ -63,12 +86,21 @@ export function healthReport(): HealthReport {
   const archiveOld = archive.todos.filter((t) => t.closedAt && daysAgo(t.closedAt) > h.archiveOldDays).length;
 
   // notes bytes across active + parked (archived excluded — sealed history).
+  // v0.5.0: track the worst-offender id so the NOTES_OVER suggestion is actionable.
   const apTodos = [...openTodos, ...ipTodos, ...parkedTodos];
-  const notesSizes = apTodos.map((t) => Buffer.byteLength(t.notes, "utf8"));
+  let maxId: string | null = null;
+  let maxSize = 0;
+  let totalBytes = 0;
+  for (const t of apTodos) {
+    const s = Buffer.byteLength(t.notes, "utf8");
+    totalBytes += s;
+    if (s > maxSize) { maxSize = s; maxId = t.id; }
+  }
   const notesBytes: NotesBytes = {
-    total: notesSizes.reduce((a, b) => a + b, 0),
-    max: notesSizes.length ? Math.max(...notesSizes) : 0,
-    avg: notesSizes.length ? Math.round(notesSizes.reduce((a, b) => a + b, 0) / notesSizes.length) : 0,
+    total: totalBytes,
+    max: maxSize,
+    maxId: apTodos.length ? maxId : null,
+    avg: apTodos.length ? Math.round(totalBytes / apTodos.length) : 0,
   };
 
   const active: ActiveHealth = {
@@ -81,6 +113,7 @@ export function healthReport(): HealthReport {
 
   const flags: HealthFlag[] = [];
   if (actionable.length > h.activeMaxOpen) flags.push("ACTIVE_LARGE");
+  if (notesBytes.max > h.maxNotesBytes) flags.push("NOTES_OVER");
   if (activeStale > 0) flags.push("ACTIVE_STALE");
   if (parkedTodos.length > h.parkedMax) flags.push("PARKED_LARGE");
   if (parkedStale > 0) flags.push("PARKED_STALE");
@@ -92,6 +125,47 @@ export function healthReport(): HealthReport {
   if (activeStale > 0) suggestions.push(`active: ${activeStale} open TODOs untouched for ${h.activeStaleDays}d → park or close them`);
   if (parkedStale > 0) suggestions.push(`parked: ${parkedStale} parked > ${h.parkedStaleDays}d → restore or hard-prune`);
   if (actionable.length > h.activeMaxOpen) suggestions.push(`active: ${actionable.length} open+in_progress (max ${h.activeMaxOpen}) → close or park some before adding more`);
-
-  return { active, parked, archive: arch, notesBytes, flags, suggestions };
+  if (notesBytes.max > h.maxNotesBytes) {
+    const id = notesBytes.maxId ?? "<id>";
+    suggestions.push(`notes: largest note ${notesBytes.max}B > cap ${h.maxNotesBytes}B (on ${id}) → trim via todo update ${id} notes:…`);
+  }
+
+  // per-project flags (v0.4.0)
+  const archivedDone = archive.todos.filter((t) => t.status === "done");
+  const projectNames = new Set<string>();
+  for (const t of live.todos) { const p = t.project.trim(); if (p) projectNames.add(p); }
+  for (const t of archivedDone) { const p = t.project.trim(); if (p) projectNames.add(p); }
+
+  const projectHealth: ProjectHealth[] = [];
+  for (const name of projectNames) {
+    const liveForName = live.todos.filter((t) => t.project.trim() === name);
+    const open = liveForName.filter((t) => t.status === "open").length;
+    const entry = getProjectEntry(synced, name);
+    const maxOpen = entry?.maxOpen ?? null;
+    const over = maxOpen !== null && open > maxOpen;
+    const large = open > h.perProjectDefaultMax;
+    const lastUpdated = liveForName.length ? liveForName.map((t) => t.updatedAt).sort().at(-1) ?? "" : "";
+    const stale = lastUpdated !== "" && daysAgo(lastUpdated) > h.activeStaleDays;
+    const totalForName = liveForName.length + archivedDone.filter((t) => t.project.trim() === name).length;
+    const typo = totalForName === 1 && [...projectNames].some((o) => o !== name && levenshtein(name, o) <= 2);
+    if (over || large || stale || typo) {
+      projectHealth.push({ name, open, maxOpen, over, typo, large, stale, lastUpdated });
+    }
+  }
+  projectHealth.sort((a, b) => b.open - a.open || a.name.localeCompare(b.name));
+
+  for (const p of projectHealth) {
+    if (p.over) { flags.push("PROJECT_OVER"); suggestions.push(`project '${p.name}' ${p.open} open (maxOpen ${p.maxOpen}) → close/park some, or raise maxOpen`); }
+    if (p.large) { flags.push("PROJECT_LARGE"); suggestions.push(`project '${p.name}' ${p.open} open (per-project default max ${h.perProjectDefaultMax}) → over budget`); }
+    if (p.stale) { flags.push("PROJECT_STALE"); suggestions.push(`project '${p.name}' untouched > ${h.activeStaleDays}d → park or close`); }
+    if (p.typo) {
+      flags.push("PROJECT_TYPO");
+      const sib = [...projectNames].find((o) => o !== p.name && levenshtein(p.name, o) <= 2);
+      suggestions.push(`project '${p.name}' has 1 todo — possible typo of '${sib}'? → todo project rename ${p.name} ${sib}`);
+    }
+  }
+
+  const noProject = { open: live.todos.filter((t) => t.project.trim() === "" && t.status === "open").length };
+
+  return { active, parked, archive: arch, notesBytes, flags, suggestions, projects: projectHealth, noProject };
 }

package/src/levenshtein.ts

@@ -0,0 +1,22 @@
+// Tiny Levenshtein edit-distance helper for project-typo nearest-sibling
+// detection. Kept dependency-free and allocation-light (two rolling rows).
+
+export function levenshtein(a: string, b: string): number {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  let prev = new Array<number>(n + 1);
+  let curr = new Array<number>(n + 1);
+  for (let j = 0; j <= n; j++) prev[j] = j;
+  for (let i = 1; i <= m; i++) {
+    curr[0] = i;
+    const ca = a.charCodeAt(i - 1);
+    for (let j = 1; j <= n; j++) {
+      const cost = ca === b.charCodeAt(j - 1) ? 0 : 1;
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[n];
+}

package/src/panel-data.ts

@@ -60,6 +60,7 @@ export function configToSettingItems(cfg: TodoConfig): SettingItem[] {
     { id: "parkedStaleDays", label: "Parked stale (days)", currentValue: String(cfg.health.parkedStaleDays), values: ["30", "60", "90"], description: "Bloat flag when parked longer than this." },
     { id: "archiveMax", label: "Archive max", currentValue: String(cfg.health.archiveMax), values: ["100", "200", "500"], description: "Bloat flag when archive exceeds this." },
     { id: "archiveOldDays", label: "Archive old (days)", currentValue: String(cfg.health.archiveOldDays), values: ["90", "180", "365"], description: "Bloat flag when archive items older than this." },
+    { id: "maxNotesBytes", label: "Notes max bytes", currentValue: String(cfg.health.maxNotesBytes), values: ["2048", "4096", "8192", "16384", "32768"], description: "Hard reject at add/update when notes exceeds this (bytes). 0 = no notes allowed." },
   ];
 }
 
@@ -79,3 +80,34 @@ export function actionsForDoneTodo(d: DoneItem): { label: string; action: string
   if (d.location === "archive") acts.push({ label: "Restore (from archive)", action: "restore" });
   return acts;
 }
+
+// v0.4.0 — project overview (Projects tab) helpers.
+import type { ProjectsOverview } from "./projects.ts";
+
+/** Format the projects overview into SelectList items. Markers: OVER / typo. */
+export function projectOverviewToItems(o: ProjectsOverview): SelectItem[] {
+  return o.rows.map((r) => {
+    const cap = r.maxOpen !== null ? ` [max:${r.maxOpen}]` : "";
+    const over = r.over ? " OVER" : "";
+    const typo = r.typo ? " ?typo" : "";
+    const last = r.lastUpdated ? ` · ${r.lastUpdated.slice(0, 10)}` : " · (no live)";
+    return {
+      value: r.name,
+      label: `${r.name}  ${r.open}/${r.in_progress}/${r.parked}/${r.done} (total ${r.total})${cap}${over}${typo}${last}`,
+    };
+  });
+}
+
+/** Actions for a project row in the Projects tab. */
+export function actionsForProject(): { label: string; action: string }[] {
+  return [
+    { label: "Rename / merge", action: "rename" },
+    { label: "Set maxOpen", action: "setmax" },
+    { label: "Filter active to project", action: "filter" },
+  ];
+}
+
+/** The (no project) summary row — non-selectable (no submenu). */
+export function noProjectSummaryItem(o: ProjectsOverview): SelectItem {
+  return { value: "__noproject__", label: `(no project): ${o.noProject.count} total · ${o.noProject.open} open` };
+}

package/src/panel.ts

@@ -24,10 +24,12 @@ import { listTodos, parkTodo, completeTodo, deleteTodo, updateTodo, type Todo, t
 import { restoreTodo, archiveSummary, listArchived, listDoneUnified } from "./archive.ts";
 import { loadConfig, saveConfig, type TodoConfig } from "./config.ts";
 import { healthReport } from "./health.ts";
-import { todoToItem, archiveSummaryToItems, actionsForTodo, configToSettingItems, todoDoneItem, actionsForDoneTodo } from "./panel-data.ts";
+import { projectsOverview } from "./projects.ts";
+import { renameProject, setProjectMaxOpen, loadRegistry, saveRegistry } from "./registry.ts";
+import { todoToItem, archiveSummaryToItems, actionsForTodo, configToSettingItems, todoDoneItem, actionsForDoneTodo, projectOverviewToItems, actionsForProject, noProjectSummaryItem } from "./panel-data.ts";
 
-export type Box = "active" | "parked" | "done" | "archive" | "config";
-const BOXES: Box[] = ["active", "parked", "done", "archive", "config"];
+export type Box = "active" | "parked" | "done" | "archive" | "projects" | "config";
+const BOXES: Box[] = ["active", "parked", "done", "archive", "projects", "config"];
 
 export interface TodoPanelOpts {
   theme: Theme;
@@ -52,6 +54,9 @@ export class TodoPanel extends Container {
   private settingsList: SettingsList | null = null;
   private config: TodoConfig;
   private healthFlags: string[] = [];
+  private projectFilterName = "";      // set by the "Filter active to project" action
+  private projectEditKind: "rename" | "setmax" | null = null;
+  private projectEditName = "";       // which project is being edited
 
   constructor(opts: TodoPanelOpts) {
     super();
@@ -101,7 +106,10 @@ export class TodoPanel extends Container {
     this.addChild(new Spacer(1));
 
     if (this.editMode && this.editInput) {
-      this.addChild(new Text(this.theme.fg("accent", `  Edit [${this.editId}]:`), 0, 0));
+      const prompt = this.projectEditKind === "rename" ? `  Rename project '${this.projectEditName}' to:`
+        : this.projectEditKind === "setmax" ? `  Set maxOpen for '${this.projectEditName}' (number or 'clear'):`
+        : `  Edit [${this.editId}]:`;
+      this.addChild(new Text(this.theme.fg("accent", prompt), 0, 0));
       this.addChild(this.editInput);
       this.addChild(new Text(this.theme.fg("dim", "  enter save • esc cancel"), 0, 0));
     } else if (this.actionMode && this.actionList) {
@@ -137,7 +145,8 @@ export class TodoPanel extends Container {
   private refreshList(): void {
     const filter = this.filterInput.getValue();
     if (this.currentBox === "active") {
-      const todos = listTodos({ text: filter || undefined, limit: 50 });
+      const project = this.projectFilterName || undefined;
+      const todos = listTodos({ project, text: filter || undefined, limit: 50 });
       this.setSelectItems(todos.map(todoToItem));
     } else if (this.currentBox === "parked") {
       const todos = listTodos({ status: "parked", text: filter || undefined, limit: 50 });
@@ -153,6 +162,10 @@ export class TodoPanel extends Container {
         const res = listArchived({ text: filter, limit: 50 });
         this.setSelectItems(res.items.map(todoToItem));
       }
+    } else if (this.currentBox === "projects") {
+      const overview = projectsOverview();
+      const rows = projectOverviewToItems(overview);
+      this.setSelectItems([noProjectSummaryItem(overview), ...rows]);
     }
   }
 
@@ -188,9 +201,87 @@ export class TodoPanel extends Container {
       this.renderShell();
       return;
     }
+    if (this.currentBox === "projects") {
+      if (item.value === "__noproject__") return;   // (no project) summary — no submenu
+      this.openProjectSubmenu(item.value);
+      return;
+    }
     this.openActionSubmenu(item.value);
   }
 
+  private openProjectSubmenu(name: string): void {
+    const acts = actionsForProject();
+    const items: SelectItem[] = acts.map((a) => ({ value: a.action, label: a.label }));
+    this.actionList = new SelectList(items, 8, {
+      selectedPrefix: (s) => this.theme.fg("accent", s),
+      selectedText: (s) => this.theme.fg("accent", s),
+      description: (s) => this.theme.fg("muted", s),
+      scrollInfo: (s) => this.theme.fg("dim", s),
+      noMatch: (s) => this.theme.fg("warning", s),
+    });
+    this.actionList.onSelect = (a) => this.executeProjectAction(name, a.value);
+    this.actionList.onCancel = () => { this.actionMode = false; this.actionList = null; this.renderShell(); };
+    this.actionMode = true;
+    this.renderShell();
+  }
+
+  private async executeProjectAction(name: string, action: string): Promise<void> {
+    try {
+      if (action === "filter") {
+        this.projectFilterName = name;
+        this.currentBox = "active";
+        this.filterInput.setValue("");   // clear text filter; scope is via projectFilterName
+        this.actionMode = false; this.actionList = null;
+        this.refreshList();
+        this.renderShell();
+        this.onNotify(`Filtered active to project: ${name}`);
+        return;
+      }
+      if (action === "rename" || action === "setmax") {
+        this.projectEditKind = action;
+        this.projectEditName = name;
+        this.editInput = new Input();
+        this.editInput.setValue("");   // don't pre-fill: setValue leaves cursor at 0 (typing would prepend); the prompt labels the target
+        this.editInput.onSubmit = (value) => {
+          try {
+            if (this.projectEditKind === "rename") {
+              const r = renameProject(this.projectEditName, value.trim());
+              this.onNotify(`Renamed ${this.projectEditName} → ${r.newName} (${r.liveRenamed} live + ${r.archivedRenamed} archived${r.merged ? ", merged" : ""})`);
+            } else if (this.projectEditKind === "setmax") {
+              const v = value.trim().toLowerCase();
+              const max = v === "clear" || v === "" ? null : Number(v);
+              if (max !== null && !Number.isFinite(max)) throw new Error("maxOpen must be a number or 'clear'");
+              const reg = loadRegistry();
+              setProjectMaxOpen(reg, this.projectEditName, max);
+              saveRegistry(reg);
+              this.onNotify(`${this.projectEditName} maxOpen = ${max === null ? "cleared" : max}`);
+            }
+          } catch (err) { this.onNotify((err as Error).message, "error"); }
+          this.exitProjectEdit();
+        };
+        this.editInput.onEscape = () => this.exitProjectEdit();
+        this.actionMode = false; this.actionList = null;
+        this.editMode = true;
+        this.renderShell();
+        return;
+      }
+    } catch (err) {
+      this.onNotify((err as Error).message, "error");
+    }
+    this.actionMode = false; this.actionList = null;
+    this.refreshList();
+    this.renderShell();
+  }
+
+  private exitProjectEdit(): void {
+    this.editMode = false;
+    this.editInput = null;
+    this.projectEditKind = null;
+    this.projectEditName = "";
+    this.refreshList();
+    this.renderShell();
+  }
+
   private openActionSubmenu(id: string): void {
     let acts: { label: string; action: string }[];
     if (this.currentBox === "done") {
@@ -301,6 +392,7 @@ export class TodoPanel extends Container {
       case "parkedStaleDays": return String(c.health.parkedStaleDays);
       case "archiveMax": return String(c.health.archiveMax);
       case "archiveOldDays": return String(c.health.archiveOldDays);
+      case "maxNotesBytes": return String(c.health.maxNotesBytes);
       default: return "";
     }
   }
@@ -317,6 +409,7 @@ export class TodoPanel extends Container {
       case "parkedStaleDays": this.config.health.parkedStaleDays = n; break;
       case "archiveMax": this.config.health.archiveMax = n; break;
       case "archiveOldDays": this.config.health.archiveOldDays = n; break;
+      case "maxNotesBytes": this.config.health.maxNotesBytes = n; break;
     }
     saveConfig(this.config);
     this.onNotify(`Config saved: ${id} = ${value}`, "info");
@@ -335,6 +428,7 @@ export class TodoPanel extends Container {
     const next = (idx + dir + BOXES.length) % BOXES.length;
     this.currentBox = BOXES[next]!;
     this.filterInput.setValue("");
+    this.projectFilterName = "";   // reset project scope on tab switch
     this.actionMode = false;
     this.actionList = null;
     this.refreshList();
@@ -344,7 +438,7 @@ export class TodoPanel extends Container {
   handleInput(data: string): void {
     if (this.editMode && this.editInput) {
       if (matchesKey(data, "escape") || matchesKey(data, "esc")) {
-        this.exitEditMode();
+        if (this.projectEditKind) this.exitProjectEdit(); else this.exitEditMode();
         return;
       }
       this.editInput.handleInput(data);