operator-deck: re-arm a dismissed card when the user edits the task

A quiet window is the floor, not a hard mute: editing a task is a signal it's live
again, so it should resurface on the deck before the cooldown elapses. Capture the
task's modifiedTime at dismissal (after the agent's own approve-write, so the agent
can't re-arm itself) as a baseline in the dismissed store { id: { at, mtime } }.
buildBatch re-arms any dismissed card whose task's current modifiedTime exceeds its
baseline — dropping it from both the covered set and the fresh() guard so the task
re-enters scope. Legacy entries carry mtime:null and fall back to time-only expiry.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: renezander030

examples/operator-deck/cadence.mjs

@@ -39,23 +39,25 @@ const COOLDOWN_MS = Number(process.env.OPERATOR_COOLDOWN_HOURS || 36) * 3600 * 1
 // Returns { map: {id: dismissedAt}, migrated } — migrates the legacy array
 // (permanent set) into a timestamped map so old entries get a fresh window once.
 function loadDismissedRaw(now = Date.now()) {
+  const norm = (v) => (typeof v === 'number' ? { at: v, mtime: null } : { at: v?.at || 0, mtime: v?.mtime ?? null });
   try {
     const j = JSON.parse(fs.readFileSync(DISMISS_FILE, 'utf-8'));
-    if (Array.isArray(j)) { const map = {}; for (const id of j) map[id] = now; return { map, migrated: true }; }
-    return { map: (j && typeof j === 'object') ? j : {}, migrated: false };
+    if (Array.isArray(j)) { const map = {}; for (const id of j) map[id] = { at: now, mtime: null }; return { map, migrated: true }; }
+    if (j && typeof j === 'object') { const map = {}; for (const [id, v] of Object.entries(j)) map[id] = norm(v); return { map, migrated: false }; }
+    return { map: {}, migrated: false };
   } catch { return { map: {}, migrated: false }; }
 }
 export function saveDismissed(map) { fs.mkdirSync(path.dirname(DISMISS_FILE), { recursive: true }); fs.writeFileSync(DISMISS_FILE, JSON.stringify(map)); }
 // Ids still inside the quiet window. Expired entries (and the legacy array form)
 // are persisted away on read so timestamps don't keep getting reset.
 export function activeDismissed(now = Date.now()) {
   const { map, migrated } = loadDismissedRaw(now);
-  const live = {}; const set = new Set();
-  for (const [id, at] of Object.entries(map)) { if (now - at < COOLDOWN_MS) { live[id] = at; set.add(id); } }
+  const live = {};
+  for (const [id, info] of Object.entries(map)) if (now - info.at < COOLDOWN_MS) live[id] = info;
   if (migrated || Object.keys(live).length !== Object.keys(map).length) saveDismissed(live);
-  return set;
+  return live;
 }
-export function dismiss(id, now = Date.now()) { const { map } = loadDismissedRaw(now); map[id] = now; saveDismissed(map); }
+export function dismiss(id, now = Date.now(), mtime = null) { const { map } = loadDismissedRaw(now); map[id] = { at: now, mtime: (mtime == null ? null : Number(mtime)) }; saveDismissed(map); }
 
 async function noteProjectSet(adapter) {
   const set = new Set();
@@ -95,7 +97,7 @@ function draftIntents(tasks) {
   });
 }
 
-export async function buildBatch(adapter, { existingIds = new Set(), dismissed = activeDismissed(), limit = BATCH } = {}) {
+export async function buildBatch(adapter, { existingIds = new Set(), dismissed: dismissedMap = activeDismissed(), limit = BATCH } = {}) {
   const now = Date.now();
   const { corpus } = await loadCorpus(adapter, { cache: true });
   const notes = await noteProjectSet(adapter);
@@ -104,6 +106,18 @@ export async function buildBatch(adapter, { existingIds = new Set(), dismissed =
   const meta = new Map(active.map((t) => [t.id, safeMeta(t)]));
   const state = loadState();
 
+  // Re-arm: a dismissed card is only still suppressing if the user hasn't edited
+  // the task since it was dismissed. modifiedTime now exceeding the baseline we
+  // captured (after the agent's own write) means a human edit -> offer it again.
+  const mtimeById = new Map(active.map((t) => [t.id, new Date(t.modifiedTime || 0).getTime()]));
+  const primaryTaskId = (id) => { const p = String(id).split(':'); return p[0] === 'relate' ? p[1] : p.slice(1).join(':'); };
+  const dismissed = new Set();
+  for (const [id, info] of Object.entries(dismissedMap)) {
+    const cur = mtimeById.get(primaryTaskId(id)) || 0;
+    if (info.mtime != null && cur > info.mtime) continue; // user touched the task -> re-armed
+    dismissed.add(id);
+  }
+
   // Candidate pool: active, non-note, titled, and NOT decayed out (benched).
   const candidates = active.filter((t) => !isNote(t) && (t.title || '').trim() && !benchReason(state, t, now));
   const byId = new Map(candidates.map((t) => [t.id, t]));

examples/operator-deck/server.mjs

@@ -47,7 +47,19 @@ async function getAdapter() {
 // permanent — it expires after the cooldown (see cadence COOLDOWN_MS), so the task
 // can be reprocessed after a quiet window of ~24-48h. `covered` keys off the active
 // set too, so the task stops being re-picked only during that window.
-function retire(id) { dismiss(id); saveQueue(loadQueue().filter((c) => c.id !== id)); }
+async function retire(id, source) {
+  // Capture the task's modifiedTime NOW (after any approve write) as the re-arm
+  // baseline: a later user edit pushes modifiedTime past this and re-offers the card.
+  let mtime = null;
+  try {
+    if (source?.projectId && source?.taskId) {
+      const t = await (await getAdapter()).getTask(source.projectId, source.taskId);
+      if (t?.modifiedTime) mtime = new Date(t.modifiedTime).getTime();
+    }
+  } catch { /* mtime is optional — fall back to time-only cooldown */ }
+  dismiss(id, Date.now(), mtime);
+  saveQueue(loadQueue().filter((c) => c.id !== id));
+}
 
 const taskOf = (card) => card?.exec?.source?.taskId || card.id;
 
@@ -121,23 +133,23 @@ const server = http.createServer(async (req, res) => {
       if (action === 'modify') {
         let note = '';
         try { note = String(JSON.parse((await readBody(req)) || '{}').note || '').slice(0, 1000); } catch { /* none */ }
-        if (!DEMO) { retire(id); recordModify(id, note); }
+        if (!DEMO) { await retire(id, card?.exec?.source); recordModify(id, note); }
         return send(res, 200, { ok: true, modified: id, note }, JSONH);
       }
 
       if (action === 'reject') {
         if (!DEMO) {
           const st = loadState(); if (card) recordSkip(st, taskOf(card)); saveState(st);
-          retire(id);
+          await retire(id, card?.exec?.source);
         }
         return send(res, 200, { ok: true, dismissed: id }, JSONH);
       }
 
       // approve
       if (!card) return send(res, 410, { error: 'suggestion no longer available' }, JSONH);
-      if (DRYRUN) { if (!DEMO) retire(id); return send(res, 200, { ok: true, dryRun: true, summary: `Would ${card.kind}` }, JSONH); }
+      if (DRYRUN) { if (!DEMO) await retire(id, card?.exec?.source); return send(res, 200, { ok: true, dryRun: true, summary: `Would ${card.kind}` }, JSONH); }
       const result = await executeSuggestion(await getAdapter(), card);
-      retire(id);
+      await retire(id, card?.exec?.source);
       return send(res, 200, { ok: true, ...result }, JSONH);
     }