@getpipher/armory-todo 0.1.0 → 0.3.0

package/src/config.ts

@@ -0,0 +1,101 @@
+// Prune + health configuration for armory-todo.
+//
+// Stored at <TODO_DIR>/todo.config.json. Missing or corrupt → defaults are
+// rewritten (the bad file is backed up to todo.config.json.bad-<ts>). All
+// values are editable (later, via the SPEC-3 /todo Config panel).
+
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { getConfigPath } from "./paths.ts";
+
+export interface PruneConfig {
+  /** Closed todos older than this (by closedAt) are moved to archive on `prune`. */
+  defaultAgeDays: number;
+  /** Archive items older than this are flagged for hard-prune suggestion. */
+  hardAgeDays: number;
+  /** Which terminal statuses get pruned. */
+  statuses: ("done" | "cancelled")[];
+}
+
+export interface HealthConfig {
+  activeMaxOpen: number;
+  activeStaleDays: number;
+  parkedMax: number;
+  parkedStaleDays: number;
+  archiveMax: number;
+  archiveOldDays: number;
+}
+
+export interface TodoConfig {
+  version: 1;
+  prune: PruneConfig;
+  health: HealthConfig;
+}
+
+export const DEFAULT_CONFIG: TodoConfig = {
+  version: 1,
+  prune: {
+    defaultAgeDays: 7,
+    hardAgeDays: 180,
+    statuses: ["done", "cancelled"],
+  },
+  health: {
+    activeMaxOpen: 15,
+    activeStaleDays: 30,
+    parkedMax: 10,
+    parkedStaleDays: 60,
+    archiveMax: 200,
+    archiveOldDays: 180,
+  },
+};
+
+/** Deep clone of DEFAULT_CONFIG (so callers can't mutate the constant). */
+function freshDefaults(): TodoConfig {
+  return JSON.parse(JSON.stringify(DEFAULT_CONFIG)) as TodoConfig;
+}
+
+export function loadConfig(): TodoConfig {
+  const path = getConfigPath();
+  if (!existsSync(path)) {
+    const cfg = freshDefaults();
+    saveConfig(cfg);
+    return cfg;
+  }
+  try {
+    const raw = readFileSync(path, "utf8");
+    const parsed = JSON.parse(raw) as TodoConfig;
+    if (!parsed || typeof parsed !== "object" || !parsed.prune || !parsed.health) {
+      throw new Error("invalid config shape");
+    }
+    // Merge with defaults so new fields get filled in on upgrade.
+    return {
+      version: 1,
+      prune: { ...DEFAULT_CONFIG.prune, ...parsed.prune },
+      health: { ...DEFAULT_CONFIG.health, ...parsed.health },
+    };
+  } catch {
+    try {
+      renameSync(path, `${path}.bad-${Date.now()}`);
+    } catch {
+      // best-effort backup
+    }
+    const cfg = freshDefaults();
+    saveConfig(cfg);
+    return cfg;
+  }
+}
+
+/** Atomic, 0600 write. */
+export function saveConfig(config: TodoConfig): void {
+  const path = getConfigPath();
+  const dir = dirname(path);
+  mkdirSync(dir, { recursive: true });
+  const tmp = `${path}.tmp`;
+  writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+  try {
+    chmodSync(tmp, 0o600);
+  } catch {
+    // some filesystems ignore mode bits
+  }
+  renameSync(tmp, path);
+}

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,97 @@
+// 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 interface NotesBytes {
+  total: number;
+  max: number;
+  avg: number;
+}
+
+export type HealthFlag =
+  | "ACTIVE_LARGE" | "ACTIVE_STALE"
+  | "PARKED_LARGE" | "PARKED_STALE"
+  | "ARCHIVE_LARGE" | "ARCHIVE_OLD";
+
+export interface HealthReport {
+  active: ActiveHealth;
+  parked: ParkedHealth;
+  archive: ArchiveHealth;
+  notesBytes: NotesBytes;
+  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;
+
+  // notes bytes across active + parked (archived excluded — sealed history).
+  const apTodos = [...openTodos, ...ipTodos, ...parkedTodos];
+  const notesSizes = apTodos.map((t) => Buffer.byteLength(t.notes, "utf8"));
+  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,
+  };
+
+  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, notesBytes, flags, suggestions };
+}

package/src/migrate.ts

@@ -0,0 +1,154 @@
+// 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";
+
+// v2 → v3 schema migration helpers. splitTextFallback is used by loadStore's
+// inline derivation (Task 1) and by migrateV2ToV3 (Task 2, with the curated
+// map). TITLE_MAX here must match the constant in todo-store.ts.
+const TITLE_MAX = 120;
+
+/** Truncate at the last word boundary ≤ TITLE_MAX (hard cut if none). No "…"
+ *  suffix — the cap is a hard rule, not a display truncation. */
+function truncateWordBoundary(s: string): string {
+  if (s.length <= TITLE_MAX) return s;
+  const slice = s.slice(0, TITLE_MAX);
+  const sp = slice.lastIndexOf(" ");
+  return sp > 0 ? slice.slice(0, sp) : slice;
+}
+
+/** Derive { title, notes } from a v2 `text` string (the fallback for any v2
+ *  todo not in the curated map). Deterministic + idempotent. */
+export function splitTextFallback(text: string): { title: string; notes: string } {
+  const raw = (text ?? "").trim();
+  if (!raw) return { title: "(untitled)", notes: "" };
+  const nl = raw.indexOf("\n");
+  if (nl < 0) {
+    if (raw.length <= TITLE_MAX) return { title: raw, notes: "" };
+    return { title: truncateWordBoundary(raw), notes: raw };
+  }
+  const firstLine = raw.slice(0, nl).trim();
+  const rest = raw.slice(nl + 1).trim();
+  if (firstLine.length <= TITLE_MAX) return { title: firstLine, notes: rest };
+  return { title: truncateWordBoundary(firstLine), notes: `${firstLine}\n${rest}` };
+}
+
+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}`);
+  }
+}
+// v2 → v3 schema migration: each todo gains title + notes (curated for the
+// 2 ids known at migration time; splitTextFallback for the rest), drops text.
+// Pure — does not touch disk. Deterministic + idempotent on v2 input.
+// (splitTextFallback + TITLE_MAX are defined above, alongside migrateIfNeeded.)
+
+/** A v2 todo (has `text`, no `title`/`notes`). */
+export interface V2Todo {
+  id: string;
+  text: string;
+  project: string;
+  tags: string[];
+  priority: string;
+  status: string;
+  source: string;
+  createdAt: string;
+  updatedAt: string;
+  closedAt: string | null;
+}
+
+/** v2 store shape (input to migrateV2ToV3). */
+export interface V2Store {
+  version: 2;
+  updatedAt: string;
+  todos: V2Todo[];
+}
+
+// Hand-curated title + notes for the 2 todos known at v2→v3 migration time
+// (the only survivors of the v0.2.0 incident). Any other v2 todo uses
+// splitTextFallback. Curated notes are reformatted for clarity, not a
+// mechanical split.
+const CURATED_V2_TO_V3: Record<string, { title: string; notes: string }> = {
+  "td-mrt3zp9fcnug3p": {
+    title: "ZeroClaw×Solana bounty — Phase 4-5: demo video (score bottleneck, unstarted)",
+    notes: `superteam.fun/earn/listing/zeroclaw · Superteam Brasil · 5,000 USDG pool / 1st=1,800 · winner Aug 21 2026 · TARGET #1.
+
+PHASE 0-2 DONE ✅. PHASE 3 (RESEARCH+SPEC+PLAN + impl alerts+custody+docs) DONE ✅ — slices A-F+H, 45 tests, committed 8fd7483→80614c8, PUSHED, PR #76 retitled "Palinurus — depin-attest + depin-rewards", 17 commits.
+
+claim_tx (G) DEFERRED — Helium hotspots are cNFTs → claim needs distribute_compression_rewards_v0 + DAS get_asset_proof (merkle proof), multi-session; PDAs verified, design in README.
+
+Decision (score-max): ship alerts core complete, pivot to DEMO track.
+
+NEXT (★ Phase 4-5, the score bottleneck — submission REQUIRES a demo video, currently unstarted):
+(1) ASYNC: RECTOR's free Relay Community key → real Helium fixtures + live smoke test;
+(2) Phase 4: wiring SVG (docs/wiring-diagram.svg, dark-mode, NOT ASCII) + marketing site (palinurus.rectorspace.com, Next.js+Tailwind+shadcn) + demo recording guide;
+(3) Phase 5: record demo ≤3min (real ZeroClaw+Telegram, terminal+phone) → ElevenLabs voiceover → ffmpeg → submit on Superteam Earn + engage #solana-bounty Discord.
+
+Test totals: 184 (71 palinurus-core + 68 depin-attest + 45 depin-rewards), all clippy+wasm clean.
+HANDOFF: ~/Documents/secret/strategy/zeroclaw-solana/session-handoff-2026-07-21.md
+Docs: {RESEARCH-3,SPEC-3,PLAN-3}-depin-rewards.md (SPEC-3 §4 + PLAN-3 G corrected for cNFT)
+Cwd: ~/local-dev/RECTOR-LABS/zeroclaw-plugins/plugins/depin-rewards
+PR: https://github.com/zeroclaw-labs/zeroclaw-plugins/pull/76`,
+  },
+  "td-mrt4e1qi9td6jz": {
+    title: "armory-todo v0.2.0 — Workstream A shipped (lifecycle boxes + prune + health + TUI)",
+    notes: `ALL 3 SPECS DONE ✅. SPEC-1 (store: parked+prune+archive+restore, 12 tasks), SPEC-2 (health+hard-prune, 6 tasks), SPEC-3 (interactive /todo TUI panel, 4 tasks). 147/147 tests across 7 suites. 24 commits on feat/spec-1-lifecycle-boxes, PR #3 retitled to full v0.2.0 scope. Auto-publish CI (release.yml, org NPM_TOKEN).
+
+INCIDENT (SPEC-1 Task 9): migration bug destroyed real 52KB/47-todo store (35 done + ~10 open lost, no backup). FIXED (c034509): migration guarded to only run when TODO_DIR is default. RECOVERED: 2 todos.
+
+Shipped: merge PR #3 → tag v0.2.0 → CI auto-publish → npm:@getpipher/armory-todo@0.2.0.
+Out of scope: B (title+notes split), C (preventive caps+project registry).`,
+  },
+};
+
+/** Transform a v2 store into a v3 store: each todo gains title + notes
+ *  (curated for the 2 known ids, splitTextFallback for the rest), drops text.
+ *  Pure — does not touch disk. Deterministic + idempotent on v2 input. */
+export function migrateV2ToV3(store: V2Store): { version: 3; updatedAt: string; todos: any[] } {
+  const todos = store.todos.map((t) => {
+    const curated = CURATED_V2_TO_V3[t.id];
+    if (curated) {
+      const { text: _drop, ...rest } = t;
+      return { ...rest, title: curated.title, notes: curated.notes };
+    }
+    const { title, notes } = splitTextFallback(t.text ?? "");
+    const { text: _drop, ...rest } = t;
+    return { ...rest, title, notes };
+  });
+  return { version: 3, updatedAt: store.updatedAt, todos };
+}

package/src/panel-data.ts

@@ -0,0 +1,63 @@
+// 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) • title".
+ *  title is already ≤120 chars (enforced at write time), so no truncation is
+ *  needed. The • marker shows when notes is non-empty (signals "open the
+ *  detail view / use `todo get` for context"). */
+export function todoToItem(t: Todo): SelectItem {
+  const pin = t.status === "in_progress" ? " ⏵" : "";
+  const proj = t.project ? ` (${t.project})` : "";
+  const dot = t.notes.trim() ? " •" : "";
+  return {
+    value: t.id,
+    label: `[${t.id}] (${t.priority})${pin}${proj}${dot} ${t.title}`,
+  };
+}
+
+/** 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 title", 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." },
+  ];
+}