@getpipher/armory-todo 0.3.0 → 0.4.0

package/extensions/todo.ts

@@ -34,12 +34,16 @@ import {
   parkTodo,
   getStorePath,
 } from "../src/todo-store";
-import { pruneTodos, restoreTodo, listArchived, archiveSummary } from "../src/archive";
+import { pruneTodos, restoreTodo, listArchived, archiveSummary, listDoneUnified } from "../src/archive";
 import { healthReport } from "../src/health";
 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})` : "";
@@ -63,19 +67,39 @@ function fmtFull(t: ReturnType<typeof getTodo>): string {
   ].join("\n");
 }
 
+function fmtDone(d: ReturnType<typeof listDoneUnified>[number]): string {
+  const tag = d.project ? ` (${d.project})` : "";
+  const loc = d.location === "archive" && d.archivedAt
+    ? ` [archived ${d.archivedAt.slice(0, 10)}]`
+    : ` [live ${d.closedAt ? Math.floor((Date.now() - Date.parse(d.closedAt)) / 86400_000) : 0}d]`;
+  return `- [${d.id}] (done)${tag} ${d.title}${loc}`;
+}
+
 export default function (pi: ExtensionAPI) {
   // Warm + report on session start (every new/resume/fork/reload).
   pi.on("session_start", async (_event, ctx) => {
     try {
+      let autoMsg = "";
+      let ageDays = 7;
+      try {
+        ageDays = loadConfig().prune.defaultAgeDays;
+        const ap = autoPruneOnSessionStart();
+        if (ap) {
+          const lines = ap.items.map((i) => `  [${i.id}] ${i.status}  ${i.title}`);
+          autoMsg = ` · auto-pruned ${ap.moved} stale done (>${ageDays}d):\n${lines.join("\n")}\nUndo any with: todo restore <id>`;
+        }
+      } catch {
+        // auto-prune optional — don't crash the session notify
+      }
       const open = listTodos();
-      let msg = `armory-todo: ${open.length} open TODO${open.length === 1 ? "" : "s"}`;
+      let msg = `armory-todo: ${open.length} open TODO${open.length === 1 ? "" : "s"}${autoMsg}`;
       try {
         const report = healthReport();
         if (report.flags.length > 0) {
-          msg += ` — ⚠ ${report.flags.length} bloat signal${report.flags.length === 1 ? "" : "s"} (run /todo health)`;
+          msg += `${autoMsg ? "\n" : " — "}` + `⚠ ${report.flags.length} bloat signal${report.flags.length === 1 ? "" : "s"} (run /todo health)`;
         }
       } catch {
-        // health check optional — don't crash the session notify
+        // health check optional
       }
       if (ctx.hasUI) ctx.ui.notify(msg, "info");
     } catch {
@@ -116,10 +140,13 @@ export default function (pi: ExtensionAPI) {
       "Use todo (action:'complete', id) to mark a TODO done; (action:'delete', id) to cancel it.",
       "Use todo (action:'park', id) to defer a TODO (not injected, recoverable); (action:'update', id, status:'open') to un-park.",
       "Use todo (action:'prune') to move done/cancelled todos to the archive (reversible); (action:'prune', all:true) to prune all regardless of age.",
+      "Done/cancelled todos older than the prune age (default 7d) auto-archive on session start — you'll see a notify; reversible via todo restore <id>. Use /todo finished or todo list status:'done' to see all finished work (live + archived).",
       "Use todo (action:'restore', id) to bring an archived TODO back as open.",
       "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). Advisory maxOpen caps are NOT enforced in v0.4.0 — they only drive a health flag; enforcement lands in v0.5.0.",
     ],
     parameters: Type.Object({
       action: StringEnum(ACTIONS),
@@ -148,11 +175,28 @@ 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 {
         switch (params.action) {
           case "list": {
+            if (params.status === "done" && !params.archived) {
+              const items = listDoneUnified({
+                text: params.text,
+                project: params.projectFilter,
+                since: params.since,
+                before: params.before,
+                limit: params.limit,
+                page: params.page,
+              });
+              if (items.length === 0) {
+                return { content: [{ type: "text" as const, text: "No done TODOs (live or archive)." }] };
+              }
+              return { content: [{ type: "text" as const, text: `Done (${items.length}):\n${items.map(fmtDone).join("\n")}` }] };
+            }
             if (params.archived) {
               const res = listArchived({
                 project: params.projectFilter,
@@ -251,17 +295,30 @@ export default function (pi: ExtensionAPI) {
               return { content: [{ type: "text" as const, text: res.message + (res.refused ? "" : ` Deleted: ${res.ids.join(", ") || "(none)"}`) }] };
             }
             const res = pruneTodos({ ageDays: params.ageDays, all: params.all });
-            return { content: [{ type: "text" as const, text: `Pruned ${res.moved} todo${res.moved === 1 ? "" : "s"} to archive: ${res.ids.join(", ") || "(none)"}` }] };
+            if (res.moved === 0) {
+              return { content: [{ type: "text" as const, text: "Nothing to prune (no stale done/cancelled)." }] };
+            }
+            const prunedLines = res.items.map((i) => `  [${i.id}] ${i.status}  ${i.title}  (was ${i.ageDays}d old)`);
+            return { content: [{ type: "text" as const, text: `Pruned ${res.moved} todo${res.moved === 1 ? "" : "s"} to archive:\n${prunedLines.join("\n")}\nUndo any with: todo restore <id>` }] };
           }
           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") }] };
@@ -275,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}` }] };
         }
@@ -290,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 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+/);
@@ -359,18 +435,32 @@ export default function (pi: ExtensionAPI) {
           }
           const all = rest.includes("--all");
           const res = pruneTodos({ all });
-          if (ctx.hasUI) ctx.ui.notify(`Pruned ${res.moved} todo${res.moved === 1 ? "" : "s"} to archive: ${res.ids.join(", ") || "(none)"}`, "info");
+          if (ctx.hasUI) {
+            const msg = res.moved === 0
+              ? "Nothing to prune."
+              : `Pruned ${res.moved} to archive:\n${res.items.map((i) => `  [${i.id}] ${i.title} (${i.ageDays}d)`).join("\n")}\nUndo: todo restore <id>`;
+            ctx.ui.notify(msg, "info");
+          }
           return;
         }
         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");
@@ -402,6 +492,12 @@ export default function (pi: ExtensionAPI) {
           if (ctx.hasUI) ctx.ui.notify(`Archived (${res.total} total):\n${msg}`, "info");
           return;
         }
+        if (sub === "finished") {
+          const items = listDoneUnified({ text: rest.join(" ").trim() || undefined, limit: 100 });
+          const msg = items.length ? `Done (${items.length}):\n${items.map(fmtDone).join("\n")}` : "(no done TODOs)";
+          if (ctx.hasUI) ctx.ui.notify(msg, "info");
+          return;
+        }
         if (sub === "clean") {
           const n = clearTodos("done");
           if (ctx.hasUI) ctx.ui.notify(`Cleared ${n} done TODOs.`, "info");
@@ -411,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.0",
+  "version": "0.4.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 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; do node test/$t.test.mts || exit 1; done"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",

package/src/archive.ts

@@ -79,9 +79,17 @@ export interface PruneInput {
   statuses?: ("done" | "cancelled")[];
 }
 
+export interface PruneItem {
+  id: string;
+  status: "done" | "cancelled";
+  title: string;
+  ageDays: number;
+}
+
 export interface PruneResult {
   moved: number;
   ids: string[];
+  items: PruneItem[];
 }
 
 /**
@@ -118,14 +126,20 @@ export function pruneTodos(opts: PruneInput = {}): PruneResult {
     moved.push(todo);
   }
 
-  if (moved.length === 0) return { moved: 0, ids: [] };
+  if (moved.length === 0) return { moved: 0, ids: [], items: [] };
 
   live.todos = kept;
   archive.todos.push(...moved);
   saveStore(live);
   saveArchive(archive);
 
-  return { moved: moved.length, ids: moved.map((t) => t.id) };
+  const items: PruneItem[] = moved.map((t) => ({
+    id: t.id,
+    status: t.status as "done" | "cancelled",
+    title: t.title,
+    ageDays: t.closedAt ? Math.floor((Date.now() - Date.parse(t.closedAt)) / 86400_000) : 0,
+  }));
+  return { moved: moved.length, ids: moved.map((t) => t.id), items };
 }
 
 /**
@@ -211,4 +225,42 @@ export function listArchived(filter: ArchiveListFilter = {}): ArchiveListResult
   const page = filter.page ?? 1;
   const start = (page - 1) * limit;
   return { items: sorted.slice(start, start + limit), total };
-}
+}
+
+export interface DoneItem extends Todo {
+  location: "live" | "archive";
+  archivedAt: string | null;
+}
+
+export interface DoneFilter {
+  text?: string;       // title OR notes substring (case-insensitive)
+  project?: string;
+  since?: string;      // closedAt >= since
+  before?: string;     // closedAt < before
+  limit?: number;      // default 50
+  page?: number;       // default 1
+}
+
+/** Unified done todos across the live store + the archive. Excludes cancelled
+ *  (Done = finished work). Sorted newest-closed first. */
+export function listDoneUnified(filter: DoneFilter = {}): DoneItem[] {
+  const live = loadStore().todos.filter((t) => t.status === "done");
+  const arch = loadArchive().todos.filter((t) => t.status === "done");
+  const items: DoneItem[] = [
+    ...live.map((t) => ({ ...t, location: "live" as const, archivedAt: null })),
+    ...arch.map((t) => ({ ...t, location: "archive" as const, archivedAt: t.closedAt })),
+  ];
+  let out = items;
+  if (filter.text) {
+    const q = filter.text.toLowerCase();
+    out = out.filter((t) => t.title.toLowerCase().includes(q) || t.notes.toLowerCase().includes(q));
+  }
+  if (filter.project) out = out.filter((t) => t.project === filter.project);
+  if (filter.since) out = out.filter((t) => (t.closedAt ?? t.updatedAt) >= (filter.since as string));
+  if (filter.before) out = out.filter((t) => (t.closedAt ?? t.updatedAt) < (filter.before as string));
+  const sorted = out.slice().sort((a, b) => (b.closedAt ?? b.updatedAt).localeCompare(a.closedAt ?? a.updatedAt));
+  const limit = filter.limit ?? 50;
+  const page = filter.page ?? 1;
+  const start = (page - 1) * limit;
+  return sorted.slice(start, start + limit);
+}

package/src/auto-prune.ts

@@ -0,0 +1,15 @@
+// Auto-prune on session_start — the deterministic age-gated prune that runs
+// when the extension loads. Wraps pruneTodos with the config default age; never
+// --all (fresh done <defaultAgeDays stays). Returns the rich PruneResult if
+// anything moved, else null (caller stays silent). Reversible via restore.
+
+import { pruneTodos, type PruneResult } from "./archive.ts";
+import { loadConfig } from "./config.ts";
+
+/** Prune stale done/cancelled (older than config.prune.defaultAgeDays) on
+ *  session start. Returns the PruneResult if anything moved, else null. */
+export function autoPruneOnSessionStart(): PruneResult | null {
+  const config = loadConfig();
+  const res = pruneTodos({ ageDays: config.prune.defaultAgeDays });
+  return res.moved > 0 ? res : null;
+}

package/src/config.ts

@@ -24,6 +24,7 @@ export interface HealthConfig {
   parkedStaleDays: number;
   archiveMax: number;
   archiveOldDays: number;
+  perProjectDefaultMax: number;  // v0.4.0: per-project PROJECT_LARGE threshold (advisory)
 }
 
 export interface TodoConfig {
@@ -46,6 +47,7 @@ export const DEFAULT_CONFIG: TodoConfig = {
     parkedStaleDays: 60,
     archiveMax: 200,
     archiveOldDays: 180,
+    perProjectDefaultMax: 8,
   },
 };
 
@@ -68,10 +70,12 @@ 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;
     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;
@@ -32,7 +34,19 @@ export interface NotesBytes {
 export type HealthFlag =
   | "ACTIVE_LARGE" | "ACTIVE_STALE"
   | "PARKED_LARGE" | "PARKED_STALE"
-  | "ARCHIVE_LARGE" | "ARCHIVE_OLD";
+  | "ARCHIVE_LARGE" | "ARCHIVE_OLD"
+  | "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 +55,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 +69,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");
@@ -93,5 +114,42 @@ export function healthReport(): HealthReport {
   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 };
+  // 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

@@ -4,6 +4,7 @@
 
 import type { SelectItem, SettingItem } from "@earendil-works/pi-tui";
 import type { Todo } from "./todo-store.ts";
+import type { DoneItem } from "./archive.ts";
 import type { ArchiveSummary } from "./archive.ts";
 import type { TodoConfig } from "./config.ts";
 
@@ -60,4 +61,52 @@ export function configToSettingItems(cfg: TodoConfig): SettingItem[] {
     { 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." },
   ];
-}
+}
+
+/** Format a done todo (live or archived) as a SelectList item with a
+ *  location tag: "[live Nd]" or "[archived YYYY-MM-DD]". */
+export function todoDoneItem(d: DoneItem): SelectItem {
+  const proj = d.project ? ` (${d.project})` : "";
+  const loc = d.location === "archive" && d.archivedAt
+    ? ` [archived ${d.archivedAt.slice(0, 10)}]`
+    : ` [live ${d.closedAt ? Math.floor((Date.now() - Date.parse(d.closedAt)) / 86400_000) : 0}d]`;
+  return { value: d.id, label: `[${d.id}] (done)${proj}${loc} ${d.title}` };
+}
+
+/** Actions for a done todo: View detail always; Restore only if archived. */
+export function actionsForDoneTodo(d: DoneItem): { label: string; action: string }[] {
+  const acts: { label: string; action: string }[] = [{ label: "View detail", action: "view" }];
+  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` };
+}