@getpipher/armory-todo 0.5.5 → 0.7.0

package/src/panel.ts

@@ -26,7 +26,7 @@ import { loadConfig, saveConfig, type TodoConfig } from "./config.ts";
 import { healthReport } from "./health.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";
+import { todoToItem, archiveSummaryToItems, actionsForTodo, configToSettingItems, todoDoneItem, actionsForDoneTodo, projectOverviewToItems, actionsForProject, noProjectSummaryItem, countReapedFromAudit } from "./panel-data.ts";
 
 export type Box = "active" | "parked" | "done" | "archive" | "projects" | "config";
 const BOXES: Box[] = ["active", "parked", "done", "archive", "projects", "config"];
@@ -54,6 +54,7 @@ export class TodoPanel extends Container {
   private settingsList: SettingsList | null = null;
   private config: TodoConfig;
   private healthFlags: string[] = [];
+  private orphanIds = new Set<string>();
   private projectFilterName = "";      // set by the "Filter active to project" action
   private projectEditKind: "rename" | "setmax" | null = null;
   private projectEditName = "";       // which project is being edited
@@ -64,7 +65,6 @@ export class TodoPanel extends Container {
     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));
@@ -132,6 +132,11 @@ export class TodoPanel extends Container {
     } else if (this.currentBox === "config") {
       this.renderConfigBox();
     } else {
+      if (this.currentBox === "archive") {
+        const reaped = countReapedFromAudit();
+        this.addChild(new Text(this.theme.fg("muted", `  reaped: ${reaped} runs auto-cancelled · restore with todo restore <id>`), 0, 0));
+        this.addChild(new Spacer(1));
+      }
       this.addChild(this.selectList);
     }
 
@@ -144,13 +149,20 @@ export class TodoPanel extends Container {
 
   private refreshList(): void {
     const filter = this.filterInput.getValue();
+    try {
+      const report = healthReport();
+      this.healthFlags = report.flags;
+      this.orphanIds = new Set(report.orphan.ids);
+    } catch {
+      // health is advisory; retain the last successful snapshot
+    }
     if (this.currentBox === "active") {
       const project = this.projectFilterName || undefined;
       const todos = listTodos({ project, text: filter || undefined, limit: 50 });
-      this.setSelectItems(todos.map(todoToItem));
+      this.setSelectItems(todos.map((t) => todoToItem(t, this.orphanIds.has(t.id))));
     } else if (this.currentBox === "parked") {
       const todos = listTodos({ status: "parked", text: filter || undefined, limit: 50 });
-      this.setSelectItems(todos.map(todoToItem));
+      this.setSelectItems(todos.map((t) => todoToItem(t)));
     } else if (this.currentBox === "done") {
       const items = listDoneUnified({ text: filter || undefined, limit: 50 });
       this.setSelectItems(items.map(todoDoneItem));
@@ -160,7 +172,7 @@ export class TodoPanel extends Container {
         this.setSelectItems(archiveSummaryToItems(s));
       } else {
         const res = listArchived({ text: filter, limit: 50 });
-        this.setSelectItems(res.items.map(todoToItem));
+        this.setSelectItems(res.items.map((t) => todoToItem(t)));
       }
     } else if (this.currentBox === "projects") {
       const overview = projectsOverview();
@@ -388,6 +400,8 @@ export class TodoPanel extends Container {
       case "hardAgeDays": return String(c.prune.hardAgeDays);
       case "activeMaxOpen": return String(c.health.activeMaxOpen);
       case "activeStaleDays": return String(c.health.activeStaleDays);
+      case "orphanFlagAfterDays": return String(c.reap.orphanFlagAfterDays);
+      case "armoryFleetReapAfterDays": return String(c.reap.policy["armory-fleet"]?.reapAfterDays ?? 2);
       case "parkedMax": return String(c.health.parkedMax);
       case "parkedStaleDays": return String(c.health.parkedStaleDays);
       case "archiveMax": return String(c.health.archiveMax);
@@ -405,6 +419,8 @@ export class TodoPanel extends Container {
       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 "orphanFlagAfterDays": this.config.reap.orphanFlagAfterDays = n; break;
+      case "armoryFleetReapAfterDays": this.config.reap.policy["armory-fleet"] = { reapAfterDays: n, reapTo: "cancelled" }; 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;
@@ -483,4 +499,4 @@ export class TodoPanel extends Container {
     this.refreshList();
     this.invalidate();
   }
-}
+}

package/src/reap.ts

@@ -0,0 +1,90 @@
+// Source-aware stale-active reaping (v0.6.0 safety protocol).
+//
+// On session_start, after auto-prune, scans active (open/in_progress) todos:
+//   - whose `source` is in config.reap.policy AND stale (updatedAt older than
+//     policy[source].reapAfterDays) → archived `cancelled` (immediately restorable).
+//   - other active todos older than config.reap.orphanFlagAfterDays → ORPHAN
+//     flag (advisory, computed in health.ts — reap does NOT mutate these).
+//
+// Batch: one loadStore, one saveStore. saveStore already calls backupFile +
+// snapshotOnDrop + appendAudit internally (same guardrails as every store write).
+
+import { appendFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { loadConfig } from "./config.ts";
+import { loadStore, saveStore, type Todo } from "./todo-store.ts";
+import { loadArchive, saveArchive } from "./archive.ts";
+import { getLivePath } from "./paths.ts";
+
+export interface ReapResult {
+  reaped: number;
+  flagged: number;        // non-policy active todos older than orphanFlagAfterDays (advisory count)
+  ids: string[];          // reaped ids
+  oldestDays: number;     // age of the oldest reaped todo (for notify copy)
+}
+
+const DAY = 86_400_000;
+
+/** Reap stale active todos per config.reap.policy into the archive. Returns
+ *  the result if any moved, else null (caller stays silent). Non-policy stale
+ *  todos are flagged via health.ts (ORPHAN) — counted but never mutated. */
+export function reapStaleActive(): ReapResult | null {
+  const config = loadConfig();
+  const policy = config.reap.policy;
+  const orphanAfter = config.reap.orphanFlagAfterDays;
+  const now = Date.now();
+
+  const store = loadStore();
+  const reaped: Todo[] = [];
+  const kept: Todo[] = [];
+  const reapedStaleDays: number[] = [];   // stale-age (by updatedAt) at decision time, pre-mutation
+  const reapedAt = new Date(now).toISOString();
+  let flagged = 0;
+
+  for (const todo of store.todos) {
+    if (todo.status !== "open" && todo.status !== "in_progress") {
+      kept.push(todo);
+      continue;
+    }
+    const ageMs = now - Date.parse(todo.updatedAt);
+    const ageDays = ageMs / DAY;
+    const entry = policy[todo.source];
+    if (entry && ageDays >= entry.reapAfterDays) {
+      todo.status = "cancelled";
+      todo.closedAt = reapedAt;
+      todo.updatedAt = reapedAt;
+      reaped.push(todo);
+      reapedStaleDays.push(ageDays);
+    } else {
+      if (!entry && ageDays >= orphanAfter) flagged++;
+      kept.push(todo);
+    }
+  }
+
+  if (reaped.length === 0) return null;
+
+  // Machine-reaped abandoned runs skip the live terminal-retention window and
+  // enter sealed history immediately, so `restoreTodo(id)` works at once.
+  const archive = loadArchive();
+  const archivedIds = new Set(archive.todos.map((t) => t.id));
+  for (const todo of reaped) {
+    if (!archivedIds.has(todo.id)) archive.todos.push(todo);
+  }
+  store.todos = kept;
+  // Persist archive first: an interrupted second write may temporarily duplicate
+  // an id across boxes, but the next idempotent reap removes the live copy. The
+  // inverse order could hide data from both primary stores until backup recovery.
+  saveArchive(archive);
+  saveStore(store, { intentionalDrop: "reap" }); // backups/snapshot/audit, no false wipe sentinel
+
+  // Append a reap-specific audit marker line (best-effort, no content)
+  try {
+    appendFileSync(
+      join(dirname(getLivePath()), "todo-audit.log"),
+      `REAP reaped=${reaped.length} flagged=${flagged} at ${new Date().toISOString()}\n`,
+    );
+  } catch { /* audit best-effort */ }
+
+  const oldestDays = reapedStaleDays.length ? Math.floor(Math.max(...reapedStaleDays)) : 0;
+  return { reaped: reaped.length, flagged, ids: reaped.map((t) => t.id), oldestDays };
+}

package/src/todo-store.ts

@@ -53,6 +53,12 @@ export interface Store {
   todos: Todo[];
 }
 
+export interface SaveStoreOptions {
+  /** Expected count-drop operation. Backups/drop snapshots/audit still run;
+   *  only the false-positive wipe sentinel is suppressed. */
+  intentionalDrop?: "reap" | "prune";
+}
+
 export interface AddInput {
   title: string;
   notes?: string;
@@ -148,7 +154,7 @@ export function loadStore(): Store {
 }
 
 /** Atomic, 0600 write. */
-export function saveStore(store: Store): void {
+export function saveStore(store: Store, options: SaveStoreOptions = {}): void {
   store.updatedAt = now();
   const path = getLivePath();
   // v0.5.1 write-audit + backup (post data-loss hardening): back up the current
@@ -168,7 +174,7 @@ export function saveStore(store: Store): void {
   }
   renameSync(tmp, path);
   appendAudit("todo", before, after, dropSnap);
-  if (after < before) writeWipeAlert(before, after, dropSnap);
+  if (after < before && !options.intentionalDrop) writeWipeAlert(before, after, dropSnap);
 }
 
 function assertPriority(p: unknown): asserts p is Priority {

package/src/triage-prompt.ts

@@ -0,0 +1,81 @@
+// The /todo triage validation rubric — a VERSIONED PROMPT CONSTANT.
+//
+// PRD ("The pipeline", stage 2): the agent prompt for the VALIDATE stage ships
+// IN the package, not improvised per session — so the rubric evolves
+// deliberately (bump TRIAGE_PROMPT_VERSION + tests when changing it) and every
+// triage run, in any session, judges against the same contract.
+//
+// The rubric is derived from PRD §D3 (which itself was distilled from the
+// 2026-08-30 manual triage). Evidence must be CHECKED (read-only git/gh/npm
+// probes), never guessed. D2 is restated here because it is load-bearing:
+// nothing mutates before the batch approval; the caller (extension) enforces
+// it mechanically — the prompt is the judgment-side half of the same gate.
+
+import type { Candidate } from "./triage.ts";
+
+export const TRIAGE_PROMPT_VERSION = "triage-rubric/v1";
+
+export const TRIAGE_RUBRIC = `## Triage rubric (${TRIAGE_PROMPT_VERSION})
+
+You are validating TODO-triage candidates. For EACH candidate, judge it against
+this rubric and produce one decision. Work top to bottom; do not skip rows.
+
+### Verdicts
+
+| Signal (checked, not guessed) | Verdict |
+|---|---|
+| source is an agent/fleet run, title is a subagent prompt, and the project work is verifiably merged/released | close (reason: debris) |
+| near-identical title/body to another LIVE todo in the same project | close (reason: duplicate) — name the surviving id |
+| done-able in <5 minutes, or explicitly deadline-bound | keep — surface it to the owner in your summary |
+| real work, low priority, no date | park |
+| stale >=30d and you could NOT verify anything | close (reason: stale-unverified) — this stays a proposal for the human |
+| fresh, in_progress, or produced by a configured auto-reap source | (never a candidate — the engine already excluded these) |
+
+### Evidence rules (D3 — checked, not guessed)
+
+- Use READ-ONLY probes only: \`git -C <repo> log --oneline -10\`,
+  \`gh run list -R <org>/<repo> --limit 3\`, \`npm view <pkg> version\`,
+  \`gh pr list -R <org>/<repo> --state merged --search <title>\`.
+- NEVER run mutating commands during validation (no push, no gh issue create,
+  no npm publish). Filing happens later, mechanically, by the tool.
+- One line of evidence per decision. If you found nothing, say what you
+  checked: "git log + npm view @x/y — no trace of the described work".
+- Confidence: high = direct proof (merged PR / published version); medium =
+  strong indirect (branch gone, issue closed by commit); low = judgment call.
+
+### Safety contract (D2 — load-bearing)
+
+- You NEVER mutate anything. Your output is proposals only.
+- The tool executes strictly what the user approves in the batch confirm.
+- A todo you cannot verify is a PROPOSAL, never an auto-close. Zero
+  false-closes is the success metric: a closed item that had to be restored
+  is a rubric bug.
+
+### Output contract
+
+Return one decision object per candidate, in order:
+
+{ "id": "<td-...>", "verdict": "close" | "park" | "keep",
+  "reason": "debris" | "duplicate" | "stale-unverified" | "verified-shipped",  // close only
+  "evidence": "<one checked line>",
+  "confidence": "high" | "medium" | "low",
+  "survivorId": "<td-...>" }   // duplicate only
+
+Then present the full proposal table (id / title / project / verdict /
+evidence / confidence) to the user and wait for ONE batch approval. On
+approval, submit all decisions in a single
+todo(action:"triage", approve:[...]) call.`;
+
+/** Compose the full agent prompt: rubric + the concrete candidate rows. */
+export function buildTriagePrompt(candidates: Candidate[], scope?: string): string {
+  const rows = candidates.map((c) => {
+    const cats = c.categories.join("+");
+    return `- [${c.todo.id}] (${c.todo.project || "no project"}, age ${c.ageDays}d, ${cats}${c.mechanicalSafe ? ", mechanical-safe" : ""}) ${c.todo.title}`;
+  });
+  return [
+    TRIAGE_RUBRIC,
+    "",
+    `## Candidates (${candidates.length}${scope ? `, scope: ${scope}` : ""})`,
+    rows.join("\n"),
+  ].join("\n");
+}