@getpipher/armory-todo 0.1.0 → 0.2.0

package/src/hard-prune.ts

@@ -0,0 +1,89 @@
+// The ONLY irreversible deletion path in armory-todo. Everything else is
+// reversible (park = status flip, prune = archive move, restore = move back).
+// hardPrune permanently deletes todos from the targeted box.
+//
+// Structural gate: refuses to execute unless `confirm: true` is passed. Even
+// if the agent hallucinates intent, the tool demands the flag. The prompt
+// guidelines (extensions/todo.ts) instruct the agent to always surface the
+// `health` report + the exact proposed command and wait for an explicit user
+// "yes" before passing confirm. The slash path uses ctx.ui.confirm.
+
+import { loadStore, saveStore } from "./todo-store.ts";
+import { loadArchive, saveArchive } from "./archive.ts";
+import type { Todo } from "./todo-store.ts";
+
+export type HardPruneBox = "archive" | "active" | "parked";
+
+export interface HardPruneInput {
+  confirm: boolean;            // REQUIRED — must be true to execute
+  box?: HardPruneBox;          // default: "archive"
+  olderThan?: number;          // days; filters by updatedAt (active/parked) or closedAt (archive)
+  project?: string;
+  tag?: string;
+}
+
+export interface HardPruneResult {
+  refused: boolean;
+  deleted: number;
+  ids: string[];
+  message: string;
+}
+
+function daysAgo(iso: string): number {
+  return (Date.now() - Date.parse(iso)) / 86400_000;
+}
+
+/**
+ * Permanently delete todos from a box. The only irreversible action.
+ * Returns `{ refused: true, deleted: 0, ... }` unless `confirm: true`.
+ */
+export function hardPrune(opts: HardPruneInput): HardPruneResult {
+  if (!opts.confirm) {
+    return {
+      refused: true,
+      deleted: 0,
+      ids: [],
+      message: "Refused: pass confirm:true to execute hard-prune (this permanently deletes).",
+    };
+  }
+  const box: HardPruneBox = opts.box ?? "archive";
+  const cutoff = opts.olderThan ? Date.now() - opts.olderThan * 86400_000 : null;
+
+  const matches = (t: Todo): boolean => {
+    if (opts.project && t.project !== opts.project) return false;
+    if (opts.tag && !t.tags.includes(opts.tag)) return false;
+    if (cutoff !== null) {
+      const dateField = box === "archive" ? (t.closedAt ?? t.updatedAt) : t.updatedAt;
+      if (Date.parse(dateField) > cutoff) return false;
+    }
+    return true;
+  };
+
+  if (box === "archive") {
+    const archive = loadArchive();
+    const kept: Todo[] = [];
+    const deleted: Todo[] = [];
+    for (const t of archive.todos) (matches(t) ? deleted : kept).push(t);
+    if (deleted.length === 0) return { refused: false, deleted: 0, ids: [], message: "No archived todos matched the criteria." };
+    archive.todos = kept;
+    saveArchive(archive);
+    return { refused: false, deleted: deleted.length, ids: deleted.map((t) => t.id), message: `Permanently deleted ${deleted.length} archived todo${deleted.length === 1 ? "" : "s"}.` };
+  }
+
+  // active or parked box → live store
+  const live = loadStore();
+  const targetStatuses = box === "parked" ? ["parked"] : ["open", "in_progress"];
+  const kept: Todo[] = [];
+  const deleted: Todo[] = [];
+  for (const t of live.todos) {
+    if (targetStatuses.includes(t.status) && matches(t)) {
+      deleted.push(t);
+    } else {
+      kept.push(t);
+    }
+  }
+  if (deleted.length === 0) return { refused: false, deleted: 0, ids: [], message: `No ${box} todos matched the criteria.` };
+  live.todos = kept;
+  saveStore(live);
+  return { refused: false, deleted: deleted.length, ids: deleted.map((t) => t.id), message: `Permanently deleted ${deleted.length} ${box} todo${deleted.length === 1 ? "" : "s"}.` };
+}

package/src/health.ts

@@ -0,0 +1,81 @@
+// Bloat diagnostics for armory-todo — a pure-read report across all three
+// lifecycle boxes (active / parked / archive), driven by the heuristics in
+// todo.config.json. No side effects. The agent surfaces this + suggestions,
+// then waits for user confirmation before any `prune --hard` (SPEC-2).
+
+import { loadStore } from "./todo-store.ts";
+import { loadArchive } from "./archive.ts";
+import { loadConfig } from "./config.ts";
+
+export interface ActiveHealth {
+  open: number;
+  in_progress: number;
+  stale_30d: number;       // open todos with updatedAt older than activeStaleDays
+}
+
+export interface ParkedHealth {
+  count: number;
+  stale_60d: number;       // parked with updatedAt older than parkedStaleDays
+}
+
+export interface ArchiveHealth {
+  count: number;
+  older_180d: number;      // closedAt older than archiveOldDays
+}
+
+export type HealthFlag =
+  | "ACTIVE_LARGE" | "ACTIVE_STALE"
+  | "PARKED_LARGE" | "PARKED_STALE"
+  | "ARCHIVE_LARGE" | "ARCHIVE_OLD";
+
+export interface HealthReport {
+  active: ActiveHealth;
+  parked: ParkedHealth;
+  archive: ArchiveHealth;
+  flags: HealthFlag[];
+  suggestions: string[];
+}
+
+function daysAgo(iso: string): number {
+  return (Date.now() - Date.parse(iso)) / 86400_000;
+}
+
+export function healthReport(): HealthReport {
+  const config = loadConfig();
+  const h = config.health;
+  const live = loadStore();
+  const archive = loadArchive();
+
+  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");
+  const actionable = [...openTodos, ...ipTodos];
+
+  const activeStale = openTodos.filter((t) => daysAgo(t.updatedAt) > h.activeStaleDays).length;
+  const parkedStale = parkedTodos.filter((t) => daysAgo(t.updatedAt) > h.parkedStaleDays).length;
+  const archiveOld = archive.todos.filter((t) => t.closedAt && daysAgo(t.closedAt) > h.archiveOldDays).length;
+
+  const active: ActiveHealth = {
+    open: openTodos.length,
+    in_progress: ipTodos.length,
+    stale_30d: activeStale,
+  };
+  const parked: ParkedHealth = { count: parkedTodos.length, stale_60d: parkedStale };
+  const arch: ArchiveHealth = { count: archive.todos.length, older_180d: archiveOld };
+
+  const flags: HealthFlag[] = [];
+  if (actionable.length > h.activeMaxOpen) flags.push("ACTIVE_LARGE");
+  if (activeStale > 0) flags.push("ACTIVE_STALE");
+  if (parkedTodos.length > h.parkedMax) flags.push("PARKED_LARGE");
+  if (parkedStale > 0) flags.push("PARKED_STALE");
+  if (archive.todos.length > h.archiveMax) flags.push("ARCHIVE_LARGE");
+  if (archiveOld > 0) flags.push("ARCHIVE_OLD");
+
+  const suggestions: string[] = [];
+  if (archiveOld > 0) suggestions.push(`archive: ${archiveOld} items older than ${h.archiveOldDays}d → consider \`prune --hard --box archive --older-than ${h.archiveOldDays} --confirm\``);
+  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, flags, suggestions };
+}

package/src/migrate.ts

@@ -0,0 +1,45 @@
+// One-time v1 → v2 migration: move the legacy single-file store
+// (~/.pi/agent/todo.json) into the v2 folder layout (~/.pi/agent/todo/todo.json).
+//
+// Pure + testable: takes explicit paths rather than reading env, so tests can
+// point at temp dirs without touching the real home directory.
+//
+// Idempotent: if the target todo.json already exists, do nothing (the user
+// already migrated, or started fresh on v2).
+
+import { copyFileSync, existsSync, mkdirSync, renameSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+
+export interface MigrateInput {
+  /** The v2 folder (e.g. ~/.pi/agent/todo/). */
+  todoDir: string;
+  /** The pre-v2 single file (e.g. ~/.pi/agent/todo.json). */
+  legacyPath: string;
+}
+
+/**
+ * If `<todoDir>/todo.json` does not exist but `legacyPath` does, create the
+ * folder and move the legacy file in. Atomic-ish: the legacy file is copied
+ * first (as a .bak), then moved, so a mid-move failure leaves the legacy file
+ * intact. Safe to call on every load.
+ */
+export function migrateIfNeeded(input: MigrateInput): void {
+  const target = join(input.todoDir, "todo.json");
+  if (existsSync(target)) return; // already v2
+  if (!existsSync(input.legacyPath)) return; // nothing to migrate
+
+  mkdirSync(input.todoDir, { recursive: true });
+  // Copy-then-rename so the legacy file survives a crash between copy + rename.
+  const backup = `${input.legacyPath}.migrate-bak-${Date.now()}`;
+  copyFileSync(input.legacyPath, backup);
+  try {
+    renameSync(input.legacyPath, target);
+    // success → remove the backup
+    try { unlinkSync(backup); } catch { /* best-effort */ }
+  } catch {
+    // rename failed → restore from backup (legacy file may have been moved
+    // on some filesystems; copy it back to be safe)
+    try { copyFileSync(backup, input.legacyPath); } catch { /* best-effort */ }
+    throw new Error(`migration failed: could not move ${input.legacyPath} → ${target}`);
+  }
+}

package/src/panel-data.ts

@@ -0,0 +1,70 @@
+// Pure data helpers for the /todo TUI panel (SPEC-3). Kept separate from
+// panel.ts so they're unit-testable without a terminal — the panel component
+// itself is manual-gate only.
+
+import type { SelectItem, SettingItem } from "@earendil-works/pi-tui";
+import type { Todo } from "./todo-store.ts";
+import type { ArchiveSummary } from "./archive.ts";
+import type { TodoConfig } from "./config.ts";
+
+/** Format a todo as a SelectList item: "[id] (prio)⏵ (project) text…".
+ *  The project tag is placed BEFORE the text so it's always visible (not
+ *  clipped at the right edge). The text is truncated to a readable summary
+ *  (first ~80 chars) so long running-log todos don't blow out the row width.
+ *  The full text is still accessible via the "Edit text" action in the panel. */
+export function todoToItem(t: Todo): SelectItem {
+  const pin = t.status === "in_progress" ? " ⏵" : "";
+  const proj = t.project ? ` (${t.project})` : "";
+  const prefix = `[${t.id}] (${t.priority})${pin}${proj}`;
+  const maxText = 80;
+  let text = t.text;
+  if (text.length > maxText) {
+    const firstLine = text.split("\n")[0]!;
+    text = firstLine.length > maxText ? firstLine.slice(0, maxText - 1) + "…" : firstLine + "…";
+  }
+  return {
+    value: t.id,
+    label: `${prefix} ${text}`,
+  };
+}
+
+/** Format an archive summary into SelectList items (project + month buckets). */
+export function archiveSummaryToItems(s: ArchiveSummary): SelectItem[] {
+  const items: SelectItem[] = [{ value: "total", label: `Total: ${s.total}` }];
+  for (const [p, n] of Object.entries(s.byProject)) items.push({ value: `project:${p}`, label: `  project ${p}: ${n}` });
+  for (const [m, n] of Object.entries(s.byMonth)) items.push({ value: `month:${m}`, label: `  ${m}: ${n}` });
+  return items;
+}
+
+/** Available actions for a todo, depending on its status. */
+export function actionsForTodo(t: Todo): { label: string; action: string }[] {
+  const actions: { label: string; action: string }[] = [];
+  if (t.status === "open" || t.status === "in_progress") {
+    actions.push({ label: "Complete", action: "complete" });
+    actions.push({ label: "Park (defer)", action: "park" });
+  }
+  if (t.status === "parked") {
+    actions.push({ label: "Re-activate (open)", action: "open" });
+    actions.push({ label: "Complete", action: "complete" });
+  }
+  if (t.status === "done" || t.status === "cancelled") {
+    actions.push({ label: "Restore (from archive)", action: "restore" });
+  }
+  actions.push({ label: "Edit text", action: "edit" });
+  actions.push({ label: "Delete (cancel)", action: "delete" });
+  return actions;
+}
+
+/** Config → SettingsList rows (editable, live-persist). */
+export function configToSettingItems(cfg: TodoConfig): SettingItem[] {
+  return [
+    { id: "defaultAgeDays", label: "Prune age (days)", currentValue: String(cfg.prune.defaultAgeDays), values: ["3", "7", "14", "30"], description: "Done/cancelled older than this → archive on prune." },
+    { id: "hardAgeDays", label: "Hard-prune age (days)", currentValue: String(cfg.prune.hardAgeDays), values: ["90", "180", "365"], description: "Archive items older than this → suggested for hard-prune." },
+    { id: "activeMaxOpen", label: "Active max open", currentValue: String(cfg.health.activeMaxOpen), values: ["10", "15", "20", "25"], description: "Bloat flag when open+in_progress exceeds this." },
+    { id: "activeStaleDays", label: "Active stale (days)", currentValue: String(cfg.health.activeStaleDays), values: ["14", "30", "60"], description: "Bloat flag when open todos untouched longer than this." },
+    { id: "parkedMax", label: "Parked max", currentValue: String(cfg.health.parkedMax), values: ["5", "10", "15"], description: "Bloat flag when parked exceeds this." },
+    { 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." },
+  ];
+}

package/src/panel.ts

@@ -0,0 +1,338 @@
+// Interactive /todo TUI panel (SPEC-3) — a Container subclass adopting the
+// @getpipher/cursor + @getpipher/vision pattern. Box tabs (Active / Parked /
+// Archive / Config), a filter Input, a SelectList, an action submenu on Enter,
+// and a SettingsList for config. Live-persist on every change. Non-TUI modes
+// fall back to ctx.ui.notify (handled by the extension, not here).
+//
+// Manual-gate: the pi-tui components need a real terminal. The pure data
+// helpers (panel-data.ts) are unit-tested; this component is verified in a
+// real pi session.
+
+import { DynamicBorder } from "@earendil-works/pi-coding-agent";
+import {
+  Container,
+  Input,
+  SelectList,
+  SettingsList,
+  Spacer,
+  Text,
+  matchesKey,
+  type SelectItem,
+  type Theme,
+} from "@earendil-works/pi-tui";
+import { listTodos, parkTodo, completeTodo, deleteTodo, updateTodo, type Todo, type Status } from "./todo-store.ts";
+import { restoreTodo, archiveSummary, listArchived } from "./archive.ts";
+import { loadConfig, saveConfig, type TodoConfig } from "./config.ts";
+import { healthReport } from "./health.ts";
+import { todoToItem, archiveSummaryToItems, actionsForTodo, configToSettingItems } from "./panel-data.ts";
+
+export type Box = "active" | "parked" | "archive" | "config";
+const BOXES: Box[] = ["active", "parked", "archive", "config"];
+
+export interface TodoPanelOpts {
+  theme: Theme;
+  onDone: () => void;
+  onNotify: (msg: string, type?: "info" | "warning" | "error") => void;
+}
+
+export class TodoPanel extends Container {
+  private readonly theme: Theme;
+  private readonly onDone: () => void;
+  private readonly onNotify: (msg: string, type?: "info" | "warning" | "error") => void;
+  private currentBox: Box = "active";
+  private filterInput: Input;
+  private selectList: SelectList;
+  private actionMode = false;
+  private actionList: SelectList | null = null;
+  private editMode = false;
+  private editInput: Input | null = null;
+  private editId = "";
+  private settingsList: SettingsList | null = null;
+  private config: TodoConfig;
+  private healthFlags: string[] = [];
+
+  constructor(opts: TodoPanelOpts) {
+    super();
+    this.theme = opts.theme;
+    this.onDone = opts.onDone;
+    this.onNotify = opts.onNotify;
+    this.config = loadConfig();
+    try { this.healthFlags = healthReport().flags; } catch { /* optional */ }
+
+    const accent = (s: string) => this.theme.fg("accent", s);
+    this.addChild(new DynamicBorder(accent));
+    this.addChild(new Spacer(1));
+
+    this.filterInput = new Input();
+    this.filterInput.onEscape = () => { this.onDone(); };
+
+    this.selectList = new SelectList([], 12, {
+      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.selectList.onSelect = (item) => this.onItemSelect(item);
+    this.selectList.onCancel = () => { this.onDone(); };
+
+    this.refreshList();
+    this.renderShell();
+  }
+
+  private renderShell(): void {
+    // Keep children 0 (top border) + 1 (spacer); rebuild the rest.
+    const keep = this.children.slice(0, 2);
+    this.children.length = 0;
+    this.children.push(...keep);
+    this.settingsList = null; // cleared; renderConfigBox sets it if active
+
+    const accent = (s: string) => this.theme.fg("accent", s);
+    const tabs = BOXES.map((b) => b === this.currentBox ? this.theme.fg("accent", this.theme.bold(`[${b}]`)) : this.theme.fg("dim", b)).join("  ");
+    this.addChild(new Text(accent(this.theme.bold("  TODO")) + "  " + tabs, 0, 0));
+    if (this.healthFlags.length > 0) {
+      this.addChild(new Text(this.theme.fg("warning", `  ⚠ ${this.healthFlags.length} bloat signals — see Config tab`), 0, 0));
+    }
+    this.addChild(new Spacer(1));
+    this.addChild(new Text(this.theme.fg("muted", "  filter:"), 0, 0));
+    this.addChild(this.filterInput);
+    this.addChild(new Spacer(1));
+
+    if (this.editMode && this.editInput) {
+      this.addChild(new Text(this.theme.fg("accent", `  Edit [${this.editId}]:`), 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) {
+      this.addChild(new Text(this.theme.fg("accent", "  Action:"), 0, 0));
+      this.addChild(this.actionList);
+    } else if (this.currentBox === "config") {
+      this.renderConfigBox();
+    } else {
+      this.addChild(this.selectList);
+    }
+
+    this.addChild(new Spacer(1));
+    this.addChild(new Text(this.theme.fg("dim", "  ↑↓ navigate • enter select/action • tab switch box • esc done"), 0, 0));
+    this.addChild(new Spacer(1));
+    this.addChild(new DynamicBorder(accent));
+    this.invalidate();
+  }
+
+  private refreshList(): void {
+    const filter = this.filterInput.getValue();
+    if (this.currentBox === "active") {
+      const todos = listTodos({ 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 });
+      this.setSelectItems(todos.map(todoToItem));
+    } else if (this.currentBox === "archive") {
+      if (!filter) {
+        const s = archiveSummary();
+        this.setSelectItems(archiveSummaryToItems(s));
+      } else {
+        const res = listArchived({ text: filter, limit: 50 });
+        this.setSelectItems(res.items.map(todoToItem));
+      }
+    }
+  }
+
+  /** Replace the SelectList's items by reconstructing it (SelectList has no
+   *  public items setter; setFilter does fuzzy matching on the original list). */
+  private setSelectItems(items: SelectItem[]): void {
+    const wasSelected = this.selectList.getSelectedItem();
+    const fresh = new SelectList(items, 12, {
+      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),
+    });
+    fresh.onSelect = (item) => this.onItemSelect(item);
+    fresh.onCancel = () => { this.onDone(); };
+    if (wasSelected) {
+      const idx = items.findIndex((i) => i.value === wasSelected.value);
+      if (idx >= 0) fresh.setSelectedIndex(idx);
+    }
+    this.selectList = fresh;
+    this.renderShell();
+  }
+
+  private onItemSelect(item: SelectItem): void {
+    if (this.currentBox === "archive" && (item.value === "total" || item.value.startsWith("project:") || item.value.startsWith("month:"))) {
+      if (item.value.startsWith("project:")) {
+        this.filterInput.setValue(item.value.slice("project:".length));
+      } else if (item.value.startsWith("month:")) {
+        this.filterInput.setValue(item.value.slice("month:".length));
+      }
+      this.refreshList();
+      this.renderShell();
+      return;
+    }
+    this.openActionSubmenu(item.value);
+  }
+
+  private openActionSubmenu(id: string): void {
+    const all = listTodos({ status: "all", limit: 200 });
+    const todo = all.find((t) => t.id === id);
+    if (!todo) {
+      this.onNotify("Todo not found in the live store (archive restore: use the archive box).", "info");
+      return;
+    }
+    const acts = actionsForTodo(todo);
+    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.executeAction(id, a.value);
+    this.actionList.onCancel = () => { this.actionMode = false; this.actionList = null; this.renderShell(); };
+    this.actionMode = true;
+    this.renderShell();
+  }
+
+  private async executeAction(id: string, action: string): Promise<void> {
+    try {
+      switch (action) {
+        case "complete": completeTodo(id); this.onNotify(`Completed ${id}`); break;
+        case "park": parkTodo(id); this.onNotify(`Parked ${id}`); break;
+        case "open": updateTodo(id, { status: "open" as Status }); this.onNotify(`Re-activated ${id}`); break;
+        case "restore": restoreTodo(id); this.onNotify(`Restored ${id}`); break;
+        case "delete": deleteTodo(id); this.onNotify(`Cancelled ${id}`); break;
+        case "edit": {
+          const all = listTodos({ status: "all", limit: 200 });
+          const t = all.find((x) => x.id === id);
+          this.editId = id;
+          this.editInput = new Input();
+          this.editInput.setValue(t?.text ?? "");
+          this.editInput.onSubmit = (value) => {
+            if (value.trim()) { updateTodo(id, { text: value.trim() }); this.onNotify(`Edited ${id}`); }
+            this.exitEditMode();
+          };
+          this.editInput.onEscape = () => this.exitEditMode();
+          this.actionMode = false;
+          this.actionList = null;
+          this.editMode = true;
+          this.renderShell();
+          break;
+        }
+      }
+    } catch (err) {
+      this.onNotify(`Error: ${(err as Error).message}`, "error");
+    }
+    this.actionMode = false;
+    this.actionList = null;
+    this.refreshList();
+    this.renderShell();
+  }
+
+  private renderConfigBox(): void {
+    const settings = configToSettingItems(this.config);
+    const sl = new SettingsList(settings, 12, {
+      label: (text, sel) => sel ? this.theme.fg("accent", this.theme.bold(text)) : text,
+      value: (text, sel) => sel ? this.theme.fg("accent", text) : this.theme.fg("muted", text),
+      description: (text) => this.theme.fg("dim", text),
+      cursor: "❯",
+      hint: (text) => this.theme.fg("dim", text),
+    },
+    (id, newValue) => {
+      this.applyConfigChange(id, newValue);
+      sl.updateValue(id, this.configValueDisplay(id));
+    },
+    () => { this.onDone(); });
+    this.settingsList = sl;
+    this.addChild(sl);
+  }
+
+  private configValueDisplay(id: string): string {
+    const c = this.config;
+    switch (id) {
+      case "defaultAgeDays": return String(c.prune.defaultAgeDays);
+      case "hardAgeDays": return String(c.prune.hardAgeDays);
+      case "activeMaxOpen": return String(c.health.activeMaxOpen);
+      case "activeStaleDays": return String(c.health.activeStaleDays);
+      case "parkedMax": return String(c.health.parkedMax);
+      case "parkedStaleDays": return String(c.health.parkedStaleDays);
+      case "archiveMax": return String(c.health.archiveMax);
+      case "archiveOldDays": return String(c.health.archiveOldDays);
+      default: return "";
+    }
+  }
+
+  private applyConfigChange(id: string, value: string): void {
+    const n = Number(value);
+    if (!Number.isFinite(n)) return;
+    switch (id) {
+      case "defaultAgeDays": this.config.prune.defaultAgeDays = n; break;
+      case "hardAgeDays": this.config.prune.hardAgeDays = n; break;
+      case "activeMaxOpen": this.config.health.activeMaxOpen = n; break;
+      case "activeStaleDays": this.config.health.activeStaleDays = n; break;
+      case "parkedMax": this.config.health.parkedMax = n; break;
+      case "parkedStaleDays": this.config.health.parkedStaleDays = n; break;
+      case "archiveMax": this.config.health.archiveMax = n; break;
+      case "archiveOldDays": this.config.health.archiveOldDays = n; break;
+    }
+    saveConfig(this.config);
+    this.onNotify(`Config saved: ${id} = ${value}`, "info");
+  }
+
+  private exitEditMode(): void {
+    this.editMode = false;
+    this.editInput = null;
+    this.editId = "";
+    this.refreshList();
+    this.renderShell();
+  }
+
+  private switchBox(dir: 1 | -1): void {
+    const idx = BOXES.indexOf(this.currentBox);
+    const next = (idx + dir + BOXES.length) % BOXES.length;
+    this.currentBox = BOXES[next]!;
+    this.filterInput.setValue("");
+    this.actionMode = false;
+    this.actionList = null;
+    this.refreshList();
+    this.renderShell();
+  }
+
+  handleInput(data: string): void {
+    if (this.editMode && this.editInput) {
+      if (matchesKey(data, "escape") || matchesKey(data, "esc")) {
+        this.exitEditMode();
+        return;
+      }
+      this.editInput.handleInput(data);
+      this.invalidate();
+      return;
+    }
+    if (this.actionMode && this.actionList) {
+      if (matchesKey(data, "escape") || matchesKey(data, "esc")) {
+        this.actionMode = false;
+        this.actionList = null;
+        this.renderShell();
+        return;
+      }
+      this.actionList.handleInput(data);
+      this.invalidate();
+      return;
+    }
+    if (matchesKey(data, "escape") || matchesKey(data, "esc")) { this.onDone(); return; }
+    if (matchesKey(data, "tab")) { this.switchBox(1); return; }
+    if (matchesKey(data, "shift+tab")) { this.switchBox(-1); return; }
+    if (matchesKey(data, "up") || matchesKey(data, "down") || matchesKey(data, "enter") || matchesKey(data, "return")) {
+      if (this.currentBox === "config" && this.settingsList) {
+        this.settingsList.handleInput(data);
+      } else {
+        this.selectList.handleInput(data);
+      }
+      this.invalidate();
+      return;
+    }
+    this.filterInput.handleInput(data);
+    this.refreshList();
+    this.invalidate();
+  }
+}

package/src/paths.ts

@@ -0,0 +1,36 @@
+// Path resolution for the armory-todo folder layout (v2).
+//
+// All store files live under TODO_DIR (default ~/.pi/agent/todo/):
+//   todo.json          — live store (open, in_progress, parked)
+//   todo-archive.json  — sealed history (done, cancelled)
+//   todo.config.json   — prune ages + health thresholds
+//
+// The legacy v1 single file was ~/.pi/agent/todo.json; migrate.ts handles
+// moving it into the folder on first load.
+
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const DEFAULT_DIR = join(homedir(), ".pi", "agent", "todo");
+const LEGACY_PATH = join(homedir(), ".pi", "agent", "todo.json");
+
+export function getTodoDir(): string {
+  return process.env.TODO_DIR || DEFAULT_DIR;
+}
+
+export function getLivePath(): string {
+  return join(getTodoDir(), "todo.json");
+}
+
+export function getArchivePath(): string {
+  return join(getTodoDir(), "todo-archive.json");
+}
+
+export function getConfigPath(): string {
+  return join(getTodoDir(), "todo.config.json");
+}
+
+/** The pre-v2 single-file store location. Used by migrate.ts. */
+export function getLegacyPath(): string {
+  return LEGACY_PATH;
+}