@axiomatic-labs/claudeflow 2.13.22 → 2.13.24

package/lib/hook-overrides.js

@@ -24,7 +24,10 @@ const path = require('path');
 
 const OVERRIDES_REL = path.join('.claudeflow', 'config', 'user-hook-overrides.json');
 const SETTINGS_REL = path.join('.claude', 'settings.json');
-const HOOK_PATH_REGEX = /\.claude\/hooks\/(.+?\.js)/;
+// Capture every `.claude/hooks/<path>.js` token in a command string. Wrapped
+// commands include both `run-with-override.js` (the wrapper) and the actual
+// hook path; we want the LAST match — that's the real handler.
+const HOOK_PATH_REGEX_GLOBAL = /\.claude\/hooks\/([^"'\s]+\.js)/g;
 
 function readJsonSafe(absPath) {
   try { return JSON.parse(fs.readFileSync(absPath, 'utf8')); } catch { return null; }
@@ -37,12 +40,18 @@ function writeJson(absPath, data) {
 
 function normalizeHandlerPath(command) {
   if (!command) return '';
-  const m = HOOK_PATH_REGEX.exec(command);
-  return m ? m[1] : command.replace(/^node\s+/, '').replace(/^["']|["']$/g, '').trim();
+  const matches = [...command.matchAll(HOOK_PATH_REGEX_GLOBAL)];
+  if (matches.length === 0) {
+    return command.replace(/^node\s+/, '').replace(/^["']|["']$/g, '').trim();
+  }
+  // Skip the wrapper itself when present; pick the last non-wrapper match.
+  const real = matches.filter((m) => m[1] !== 'run-with-override.js');
+  const chosen = real.length ? real[real.length - 1] : matches[matches.length - 1];
+  return chosen[1];
 }
 
 function defaultOverrides() {
-  return { version: 1, disabledHandlers: [] };
+  return { version: 1, disabledHandlers: [], disabledReminders: [] };
 }
 
 function readOverrides(projectRoot) {
@@ -51,6 +60,7 @@ function readOverrides(projectRoot) {
   return {
     version: data.version || 1,
     disabledHandlers: Array.isArray(data.disabledHandlers) ? data.disabledHandlers : [],
+    disabledReminders: Array.isArray(data.disabledReminders) ? data.disabledReminders : [],
   };
 }
 
@@ -128,10 +138,13 @@ function restoreHandlerInSettings(settings, event, matcher, spec) {
   if (!already) rule.hooks.push(spec);
 }
 
-// Stateful toggle used by the panel.
-//   - disable=true: capture spec from current settings.json, append to
-//     overrides, remove from settings.json
-//   - disable=false: pop spec from overrides, restore to settings.json
+// Stateful toggle used by the panel. Only edits overrides.json — settings.json
+// is never mutated. The wrapper (.claude/hooks/run-with-override.js) reads
+// overrides on every invocation, so disable/enable takes effect on the next
+// hook fire (no Claude Code restart required).
+//
+// Settings.json is also consulted to verify the handler exists at all
+// (refuses to disable a phantom handler), but it is never written.
 function toggleHookOverride(projectRoot, { event, matcher = '', handler, disable }) {
   const settingsPath = path.join(projectRoot, SETTINGS_REL);
   const settings = readJsonSafe(settingsPath) || { hooks: {} };
@@ -143,12 +156,11 @@ function toggleHookOverride(projectRoot, { event, matcher = '', handler, disable
       (d) => d.event === event && (d.matcher || '') === matcherKey && d.handler === handler,
     );
     if (already) return { state: 'noop', reason: 'already-disabled' };
-    const spec = findHandlerInSettings(settings, event, matcherKey, handler);
-    if (!spec) return { state: 'error', reason: 'handler-not-found-in-settings' };
-    overrides.disabledHandlers.push({ event, matcher: matcherKey, handler, spec });
+    if (!findHandlerInSettings(settings, event, matcherKey, handler)) {
+      return { state: 'error', reason: 'handler-not-found-in-settings' };
+    }
+    overrides.disabledHandlers.push({ event, matcher: matcherKey, handler });
     writeOverrides(projectRoot, overrides);
-    const next = applyHookOverrides(settings, overrides);
-    fs.writeFileSync(settingsPath, JSON.stringify(next, null, 2) + '\n');
     return { state: 'disabled' };
   }
 
@@ -156,10 +168,27 @@ function toggleHookOverride(projectRoot, { event, matcher = '', handler, disable
     (d) => d.event === event && (d.matcher || '') === matcherKey && d.handler === handler,
   );
   if (idx === -1) return { state: 'noop', reason: 'not-disabled' };
-  const [removed] = overrides.disabledHandlers.splice(idx, 1);
-  if (!removed.spec) return { state: 'error', reason: 'no-spec-recorded' };
-  restoreHandlerInSettings(settings, event, matcherKey, removed.spec);
-  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+  overrides.disabledHandlers.splice(idx, 1);
+  writeOverrides(projectRoot, overrides);
+  return { state: 'enabled' };
+}
+
+// Toggle a single reminder by id. Same persistence file, same hot-reload
+// semantics — `reload-reminder.js` re-reads overrides on every invocation.
+function toggleReminderOverride(projectRoot, { id, disable }) {
+  if (typeof id !== 'string' || !id.trim()) return { state: 'error', reason: 'id-required' };
+  const overrides = readOverrides(projectRoot);
+  const list = overrides.disabledReminders;
+  const idx = list.indexOf(id);
+
+  if (disable) {
+    if (idx !== -1) return { state: 'noop', reason: 'already-disabled' };
+    list.push(id);
+    writeOverrides(projectRoot, overrides);
+    return { state: 'disabled' };
+  }
+  if (idx === -1) return { state: 'noop', reason: 'not-disabled' };
+  list.splice(idx, 1);
   writeOverrides(projectRoot, overrides);
   return { state: 'enabled' };
 }
@@ -172,6 +201,7 @@ module.exports = {
   readOverrides,
   writeOverrides,
   toggleHookOverride,
+  toggleReminderOverride,
   normalizeHandlerPath,
   matchesOverride,
 };

package/lib/install.js

@@ -86,10 +86,9 @@ async function run() {
     fs.mkdirSync(path.join(cwd, '.claude'), { recursive: true });
     if (fs.existsSync(srcSettings)) {
       syncClaudeSettings(srcSettings, dstSettings);
-      // Re-apply user hook overrides (if any) so disabled handlers stay
-      // disabled across update — without this, every update would resurrect
-      // hooks the user explicitly turned off via `claudeflow panel`.
-      applyHookOverridesToFile(cwd);
+      // Settings.json now ships with every hook command wrapped through
+      // run-with-override.js. The wrapper consults user-hook-overrides.json
+      // at invocation time, so toggles persist without any settings rewrite.
     }
 
     // Upsert playwright entry in .mcp.json with project-specific CDP port.

package/lib/panel.js

@@ -24,9 +24,26 @@ const {
 const {
   readOverrides,
   toggleHookOverride,
+  toggleReminderOverride,
   normalizeHandlerPath,
 } = require('./hook-overrides.js');
 
+// Lazy-load the reminder catalog from the template hook helper. The path
+// resolves the same way at install time and from the template repo.
+function loadReminderHelpers(cwd) {
+  const candidates = [
+    path.join(cwd, '.claude', 'hooks', 'shared', 'reload-reminder.js'),
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c)) {
+      // Bypass require cache so updates to the template are picked up.
+      delete require.cache[require.resolve(c)];
+      return require(c);
+    }
+  }
+  return null;
+}
+
 const IDLE_SHUTDOWN_MS = 30 * 60 * 1000; // 30 min
 
 // ─── data collectors ─────────────────────────────────────────────
@@ -96,14 +113,18 @@ function getHooksInfo(cwd) {
     disabledIndex.set(`${d.event}|${d.matcher || ''}|${d.handler}`, d);
   }
 
+  // settings.json lists every hook (with each command wrapped through
+  // run-with-override.js). The wrapper checks overrides at invocation time,
+  // so the panel just annotates each handler with its current disabled
+  // state from the overrides file.
   const hooks = settings.hooks || {};
-  const eventsMap = new Map();
+  const events = [];
   let totalHandlers = 0;
   let warnings = 0;
   let disabledCount = 0;
 
   for (const [event, rules] of Object.entries(hooks)) {
-    if (!eventsMap.has(event)) eventsMap.set(event, []);
+    const handlers = [];
     for (const rule of rules) {
       const matcher = rule.matcher || '';
       for (const h of rule.hooks || []) {
@@ -111,44 +132,28 @@ function getHooksInfo(cwd) {
         const handlerPath = normalizeHandlerPath(cmd) || (cmd ? cmd : '');
         const isEmpty = !handlerPath;
         if (isEmpty) warnings++;
-        eventsMap.get(event).push({
+        const key = `${event}|${matcher}|${handlerPath}`;
+        const isDisabled = disabledIndex.has(key);
+        if (isDisabled) disabledCount++;
+        handlers.push({
           handler: handlerPath || '(empty command)',
-          matcher: matcher || '',
+          matcher,
           matcherDisplay: matcher || '(any)',
           empty: isEmpty,
-          disabled: false,
+          disabled: isDisabled,
           rawCommand: cmd,
         });
         totalHandlers++;
       }
     }
+    events.push({ event, count: handlers.length, handlers });
   }
 
-  // Add disabled handlers (live in overrides, not in settings.json)
-  for (const d of overrides.disabledHandlers || []) {
-    if (!eventsMap.has(d.event)) eventsMap.set(d.event, []);
-    eventsMap.get(d.event).push({
-      handler: d.handler,
-      matcher: d.matcher || '',
-      matcherDisplay: d.matcher || '(any)',
-      empty: false,
-      disabled: true,
-      rawCommand: (d.spec && d.spec.command) || '',
-    });
-    disabledCount++;
-  }
-
-  const events = Array.from(eventsMap.entries()).map(([event, handlers]) => ({
-    event,
-    count: handlers.length,
-    handlers,
-  }));
-
   return {
     settingsFound: true,
     events,
-    totalHandlers: totalHandlers + disabledCount,
-    activeHandlers: totalHandlers,
+    totalHandlers,
+    activeHandlers: totalHandlers - disabledCount,
     disabledHandlers: disabledCount,
     warnings,
   };
@@ -239,6 +244,29 @@ function getActiveRunInfo(cwd) {
   };
 }
 
+function getRemindersInfo(cwd) {
+  const helpers = loadReminderHelpers(cwd);
+  if (!helpers || typeof helpers.listReminderCatalog !== 'function') {
+    return { available: false, reminders: [], disabledCount: 0 };
+  }
+  const catalog = helpers.listReminderCatalog();
+  const overrides = readOverrides(cwd);
+  const disabledSet = new Set(overrides.disabledReminders || []);
+  const reminders = catalog.map((r) => ({
+    id: r.id,
+    label: r.label,
+    description: r.description,
+    slot: r.slot,
+    disabled: disabledSet.has(r.id),
+  }));
+  return {
+    available: true,
+    reminders,
+    disabledCount: reminders.filter((r) => r.disabled).length,
+    activeCount: reminders.filter((r) => !r.disabled).length,
+  };
+}
+
 function getDoctorInfo(cwd) {
   const checks = [checkCdpPortMismatch(cwd), checkStaleLockfiles(cwd)];
   const issues = checks.filter((c) => c.severity !== 'ok' && c.severity !== 'info');
@@ -259,6 +287,7 @@ function collectStatus(cwd) {
     mcp: getMcpInfo(cwd),
     setupContext: getSetupContextInfo(cwd),
     activeRun: getActiveRunInfo(cwd),
+    reminders: getRemindersInfo(cwd),
     doctor: getDoctorInfo(cwd),
   };
 }
@@ -350,6 +379,12 @@ details[open] summary { padding-bottom: 8px; border-bottom: 1px solid var(--bord
 .toggle input { accent-color: var(--accent); }
 .disabled-row { opacity: 0.55; }
 .disabled-row .matcher { font-style: italic; }
+.reminder-row { padding: 10px 0; border-bottom: 1px solid var(--border); }
+.reminder-row:last-child { border-bottom: 0; }
+.reminder-row .reminder-label { font-size: 13px; }
+.reminder-row .reminder-desc { font-size: 12px; margin-left: 22px; margin-top: 2px; }
+.reminder-row .reminder-id { font-size: 11px; margin-left: 22px; margin-top: 2px; }
+.reminder-row code { background: var(--panel-2); padding: 1px 5px; border-radius: 3px; font-size: 11px; }
 .toast { position: fixed; bottom: 18px; right: 18px; background: var(--panel); border: 1px solid var(--border); padding: 10px 14px; border-radius: 6px; font-size: 13px; box-shadow: 0 4px 12px rgba(0,0,0,0.4); }
 .toast.err { border-color: var(--err); }
 .toast.ok { border-color: var(--ok); }
@@ -375,6 +410,7 @@ const SECTIONS = [
   { id: 'overview',     label: 'Overview' },
   { id: 'claudeMd',     label: 'CLAUDE.md' },
   { id: 'hooks',        label: 'Hooks' },
+  { id: 'reminders',    label: 'Reminders' },
   { id: 'mcp',          label: 'MCP & observer' },
   { id: 'setupContext', label: 'Setup context' },
   { id: 'activeRun',    label: 'Active run' },
@@ -385,12 +421,66 @@ let state = null;
 let active = 'overview';
 let timer = null;
 
+// Preserve which <details> were open across re-renders (auto-refresh would
+// otherwise collapse them every 5s).
+function captureOpenDetails() {
+  const ids = new Set();
+  document.querySelectorAll('details[open][data-detail-id]').forEach(d => ids.add(d.dataset.detailId));
+  // Also capture anonymous details by event name (hooks accordion).
+  document.querySelectorAll('details[open][data-event]').forEach(d => ids.add('event:' + d.dataset.event));
+  return ids;
+}
+
+function restoreOpenDetails(ids) {
+  if (!ids.size) return;
+  document.querySelectorAll('details[data-detail-id]').forEach(d => {
+    if (ids.has(d.dataset.detailId)) d.open = true;
+  });
+  document.querySelectorAll('details[data-event]').forEach(d => {
+    if (ids.has('event:' + d.dataset.event)) d.open = true;
+  });
+}
+
+// Cache fetched CLAUDE.md content so re-renders during auto-refresh don't
+// drop the preview the user already loaded.
+let claudeMdCache = null;
+
+async function loadClaudeMdPreview() {
+  const target = document.getElementById('claude-md-preview');
+  if (!target) return;
+  if (target.dataset.loaded === '1') return;
+  target.dataset.loaded = '1';
+  target.textContent = 'Loading…';
+  try {
+    if (!claudeMdCache) {
+      const r = await fetch('/api/claude-md');
+      claudeMdCache = await r.text();
+    }
+    const pre = document.createElement('pre');
+    pre.textContent = claudeMdCache;
+    target.innerHTML = '';
+    target.appendChild(pre);
+  } catch (e) {
+    target.textContent = 'Failed to load: ' + e.message;
+    target.dataset.loaded = '';
+  }
+}
+
 async function refresh() {
-  const r = await fetch('/api/status');
-  state = await r.json();
+  const open = captureOpenDetails();
+  try {
+    const r = await fetch('/api/status');
+    state = await r.json();
+  } catch (e) {
+    showToast && showToast('Refresh failed: ' + e.message, 'err');
+    return;
+  }
   renderHeader();
   renderNav();
   renderContent();
+  restoreOpenDetails(open);
+  // If preview was visible/open, ensure it stays loaded after re-render.
+  if (open.has('claude-md-preview')) loadClaudeMdPreview();
 }
 
 function renderHeader() {
@@ -404,6 +494,7 @@ function severityFor(id) {
     case 'overview': return s.doctor.issueCount > 0 ? 'warn' : 'ok';
     case 'claudeMd': return !s.claudeMd.exists ? 'err' : (s.claudeMd.optOut ? 'info' : 'ok');
     case 'hooks':    return s.hooks.warnings > 0 ? 'warn' : 'ok';
+    case 'reminders': return s.reminders && s.reminders.disabledCount > 0 ? 'info' : 'ok';
     case 'mcp':      return !s.mcp.configFound ? 'info' : (s.mcp.playwright.match && s.mcp.staleLockfiles.length === 0 ? 'ok' : 'warn');
     case 'setupContext': return !s.setupContext.exists ? 'err' : (s.setupContext.toolingComplete ? 'ok' : 'warn');
     case 'activeRun': return s.activeRun.active ? 'info' : 'info';
@@ -447,6 +538,7 @@ function renderContent() {
     overview: renderOverview,
     claudeMd: renderClaudeMd,
     hooks: renderHooks,
+    reminders: renderReminders,
     mcp: renderMcp,
     setupContext: renderSetup,
     activeRun: renderRun,
@@ -468,6 +560,9 @@ function renderOverview() {
   const sc = !s.setupContext.exists ? 'missing' : (s.setupContext.toolingComplete ? 'complete' : 'incomplete (' + s.setupContext.missingTooling.join(', ') + ')');
   const ar = s.activeRun.active ? s.activeRun.runId : 'none';
   const dc = s.doctor.issueCount === 0 ? '0 issues' : s.doctor.issueCount + ' issue(s) — run \`claudeflow doctor\`';
+  const rm = s.reminders && s.reminders.available
+    ? \`\${s.reminders.activeCount} active · \${s.reminders.disabledCount} disabled\`
+    : 'unavailable';
   return \`<h2>Overview</h2>
     <p class="sub">Snapshot at \${new Date(s.timestamp).toLocaleTimeString()}</p>
     <div class="card">
@@ -477,6 +572,7 @@ function renderOverview() {
       \${row('MCP & observer', mc, { kind: !s.mcp.configFound ? 'info' : (s.mcp.playwright.match ? 'ok' : 'warn'), text: !s.mcp.configFound ? '·' : (s.mcp.playwright.match ? '✓' : '!') })}
       \${row('Setup context', sc, { kind: s.setupContext.exists ? (s.setupContext.toolingComplete ? 'ok' : 'warn') : 'err', text: s.setupContext.exists ? (s.setupContext.toolingComplete ? '✓' : '!') : '✗' })}
       \${row('Active run', ar, { kind: 'info', text: s.activeRun.active ? '·' : '·' })}
+      \${row('Reminders', rm, { kind: s.reminders && s.reminders.available ? (s.reminders.disabledCount ? 'info' : 'ok') : 'err', text: s.reminders && s.reminders.disabledCount ? '·' : '✓' })}
       \${row('Doctor', dc, { kind: s.doctor.issueCount === 0 ? 'ok' : 'warn', text: s.doctor.issueCount === 0 ? '✓' : '!' })}
     </div>\`;
 }
@@ -494,12 +590,7 @@ function renderClaudeMd() {
       \${row('Default rules block', blk, { kind: c.block.present ? 'ok' : 'info', text: c.block.present ? '✓' : '·' })}
       \${row('Opt-out marker', c.optOut ? 'present (block disabled)' : 'absent', { kind: c.optOut ? 'info' : 'ok', text: c.optOut ? '·' : '✓' })}
     </div>
-    <details><summary>Preview content</summary><div id="claude-md-preview">Loading…</div></details>
-    <script>
-      fetch('/api/claude-md').then(r => r.text()).then(t => {
-        document.getElementById('claude-md-preview').innerHTML = '<pre>' + t.replace(/[&<>]/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;'}[c])) + '</pre>';
-      });
-    </\${'script'}>
+    <details data-detail-id="claude-md-preview"><summary>Preview content</summary><div id="claude-md-preview" class="muted">Click to load…</div></details>
   \`;
 }
 
@@ -519,7 +610,7 @@ function renderHooks() {
         <span class="matcher">\${escapeHtml(hd.matcherDisplay)}</span>
       </div>\`;
     }).join('');
-    return \`<details><summary>\${escapeHtml(ev.event)} <span class="muted">(\${ev.count})</span></summary>\${handlers}</details>\`;
+    return \`<details data-event="\${escapeHtml(ev.event)}"><summary>\${escapeHtml(ev.event)} <span class="muted">(\${ev.count})</span></summary>\${handlers}</details>\`;
   }).join('');
   return \`<h2>Hooks</h2>
     <p class="sub">\${h.events.length} events · \${h.activeHandlers} active\${h.disabledHandlers ? ' · <span class="muted">' + h.disabledHandlers + ' disabled</span>' : ''}\${h.warnings ? ' · <span class="warning">' + h.warnings + ' warnings</span>' : ''}</p>
@@ -527,6 +618,35 @@ function renderHooks() {
     \${items}\`;
 }
 
+function renderReminders() {
+  const r = state.reminders;
+  if (!r || !r.available) return '<h2>Reminders</h2><p class="error">Reminder catalog unavailable (template helper not found).</p>';
+  const slotLabel = { reads: 'Reads / anchors', rules: 'Rules', 'claude-md': 'CLAUDE.md content' };
+  const grouped = {};
+  for (const item of r.reminders) {
+    if (!grouped[item.slot]) grouped[item.slot] = [];
+    grouped[item.slot].push(item);
+  }
+  const sections = Object.entries(grouped).map(([slot, items]) => {
+    const rows = items.map(item => {
+      const checked = item.disabled ? '' : 'checked';
+      const dataset = \`data-id="\${escapeHtml(item.id)}"\`;
+      const status = item.disabled ? '<span class="badge info">disabled</span>' : '';
+      const cls = item.disabled ? 'reminder-row disabled-row' : 'reminder-row';
+      return \`<div class="\${cls}">
+        <label class="toggle"><input type="checkbox" class="reminder-toggle" \${dataset} \${checked} />
+          <span class="reminder-label"><strong>\${escapeHtml(item.label)}</strong> \${status}</span></label>
+        <div class="reminder-desc muted">\${escapeHtml(item.description)}</div>
+        <div class="reminder-id muted">id: <code>\${escapeHtml(item.id)}</code></div>
+      </div>\`;
+    }).join('');
+    return \`<details open><summary>\${escapeHtml(slotLabel[slot] || slot)} <span class="muted">(\${items.length})</span></summary>\${rows}</details>\`;
+  }).join('');
+  return \`<h2>Reminders</h2>
+    <p class="sub">\${r.activeCount} active · \${r.disabledCount} disabled. Toggles are read by <code>reload-reminder.js</code> on every hook invocation — disabling takes effect on the next user prompt without reloading Claude Code.</p>
+    \${sections}\`;
+}
+
 function renderMcp() {
   const m = state.mcp;
   if (!m.configFound) return '<h2>MCP & observer</h2><p class="muted">.mcp.json not found</p>';
@@ -607,17 +727,52 @@ async function toggleHook(event, matcher, handler, disable) {
   await refresh();
 }
 
+async function toggleReminder(id, disable) {
+  try {
+    const r = await fetch('/api/reminders/toggle', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ id, disable }),
+    });
+    const result = await r.json();
+    if (!r.ok || result.state === 'error') {
+      showToast('Toggle failed: ' + (result.reason || result.error || 'unknown'), 'err');
+    } else if (result.state === 'noop') {
+      showToast('Already in target state', 'ok');
+    } else {
+      showToast(disable ? 'Reminder silenced. Next prompt will skip it.' : 'Reminder restored. Next prompt will include it.', 'ok');
+    }
+  } catch (e) {
+    showToast('Network error: ' + e.message, 'err');
+  }
+  await refresh();
+}
+
 document.addEventListener('change', (e) => {
   const t = e.target;
-  if (t && t.classList && t.classList.contains('hook-toggle')) {
+  if (!t || !t.classList) return;
+  if (t.classList.contains('hook-toggle')) {
     const event = t.dataset.event;
     const matcher = t.dataset.matcher;
     const handler = t.dataset.handler;
     const disable = !t.checked;
     toggleHook(event, matcher, handler, disable);
+  } else if (t.classList.contains('reminder-toggle')) {
+    const id = t.dataset.id;
+    const disable = !t.checked;
+    toggleReminder(id, disable);
   }
 });
 
+// Lazy-load CLAUDE.md preview when the user opens the details element.
+// The "toggle" event does not bubble by default — capture phase keeps delegation working.
+document.addEventListener('toggle', (e) => {
+  const t = e.target;
+  if (t && t.tagName === 'DETAILS' && t.dataset.detailId === 'claude-md-preview' && t.open) {
+    loadClaudeMdPreview();
+  }
+}, true);
+
 document.getElementById('refresh').onclick = refresh;
 document.getElementById('auto').onchange = (e) => {
   if (timer) clearInterval(timer);
@@ -687,6 +842,20 @@ function handler(cwd) {
         return send(status, JSON.stringify(result), 'application/json');
       }
 
+      if (req.method === 'POST' && route === '/api/reminders/toggle') {
+        const raw = await readRequestBody(req);
+        let payload;
+        try { payload = JSON.parse(raw); }
+        catch { return send(400, JSON.stringify({ error: 'invalid json' }), 'application/json'); }
+        const { id, disable } = payload;
+        if (typeof id !== 'string' || typeof disable !== 'boolean') {
+          return send(400, JSON.stringify({ error: 'id, disable required' }), 'application/json');
+        }
+        const result = toggleReminderOverride(cwd, { id, disable });
+        const status = result.state === 'error' ? 500 : 200;
+        return send(status, JSON.stringify(result), 'application/json');
+      }
+
       send(404, JSON.stringify({ error: 'not found' }), 'application/json');
     } catch (err) {
       res.writeHead(500, { 'Content-Type': 'application/json' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiomatic-labs/claudeflow",
-  "version": "2.13.22",
+  "version": "2.13.24",
   "description": "Claudeflow — AI-powered development toolkit for Claude Code. Skills, agents, hooks, and quality gates that ship production apps.",
   "bin": {
     "claudeflow": "./bin/cli.js"