synabun 2.0.10 → 2.2.0

package/neural-interface/public/shared/schedules-view.js

@@ -1,3 +1,4 @@
+import { toolListView } from './tool-list-view.js';
 // SynaBun Neural Interface — what the Schedules window shows, without the page.
 // Which schedules a view lists and in which order, how a schedule's state reads, and the cron
 // in plain words. ui-schedules-studio.js draws it; tests import this file under Node, so it
@@ -11,49 +12,161 @@ export const OVERDUE_AFTER = 5 * MINUTE;
 // "Up next" looks this far ahead.
 export const UP_NEXT_WINDOW = DAY;
 
-const DAY_SHORT = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
-
 export const VIEW_SCOPES = ['upcoming', 'all', 'attention', 'paused', 'timers', 'activity'];
 export const LIST_SCOPES = ['upcoming', 'all', 'attention', 'paused'];
 export const SORTS = ['next', 'name', 'last'];
 
+// ── Words ──
+// SCHEDULES_VIEW_COPY is the English of every word this file shows: `schedules.view.*` in
+// i18n/en.json must equal it, and every locale file holds the same keys (the test checks both).
+// A `{ one, other }` entry is counted, as i18n's tp() counts. Without a translator (tests, Node)
+// the English reads as written; the window installs i18n's t() and the app's locale with
+// setSchedulesViewTranslator.
+export const SCHEDULES_VIEW_COPY = Object.freeze({
+  everyDay: 'Every day',
+  weekdays: 'Weekdays',
+  weekends: 'Weekends',
+  dayRange: '{from}–{to}',
+  monthDays: { one: 'Day {days} of every month', other: 'Days {days} of every month' },
+  everyMinutes: { one: 'every minute', other: 'every {count} minutes' },
+  everyHoursAt: { one: 'every hour at :{minute}', other: 'every {count} hours at :{minute}' },
+  everyHourBetween: 'every hour from {from} to {to}',
+  daysAt: '{days} at {times}',
+  daysEvery: '{days}, {every}',
+  listAnd: '{list} and {last}',
+  dayShort: { sun: 'Sun', mon: 'Mon', tue: 'Tue', wed: 'Wed', thu: 'Thu', fri: 'Fri', sat: 'Sat' },
+  dayLong: { sun: 'Sunday', mon: 'Monday', tue: 'Tuesday', wed: 'Wednesday', thu: 'Thursday', fri: 'Friday', sat: 'Saturday' },
+  runNever: 'Not run yet',
+  runCompleted: 'Completed',
+  runStarted: 'Started',
+  runAutomationMissing: 'Automation missing',
+  runAutomationMissingReason: 'The automation this schedule launches no longer exists.',
+  runFailed: 'Failed',
+  runFailedReason: 'The run failed.',
+  runStopped: 'Stopped',
+  runStoppedByYou: 'Stopped by you',
+  runInterrupted: 'Interrupted',
+  notScheduled: 'Not scheduled',
+  dueNow: 'Due now',
+  overdue: 'Overdue',
+  inSeconds: 'in {n} s',
+  inMinutes: 'in {n} min',
+  inHoursMinutes: 'in {h} h {m} min',
+  inHours: 'in {h} h',
+  inDaysHours: 'in {d} d {h} h',
+  inDays: 'in {d} d',
+  justNow: 'just now',
+  minutesAgo: '{n} min ago',
+  hoursAgo: '{n} h ago',
+  yesterdayAgo: 'yesterday',
+  daysAgo: '{n} d ago',
+  today: 'Today',
+  tomorrow: 'Tomorrow',
+  yesterday: 'Yesterday',
+  dayAt: '{day} {time}',
+  tomorrowAt: 'Tomorrow {time}',
+  weekdayAt: '{day} {time}',
+  factCli: 'CLI',
+  factModel: 'Model',
+  factContext: 'Context',
+  factThinking: 'Thinking',
+  factMcp: 'Tools and MCP servers',
+  factAccount: 'OpenAI account',
+  factBrowser: 'Browser',
+  valueDefault: 'Default',
+  valueOn: 'On',
+  valueOff: 'Off',
+  context1m: '1M tokens',
+  contextExtended: 'Extended',
+  effort: { none: 'None', minimal: 'Minimal', low: 'Low', medium: 'Medium', high: 'High', xhigh: 'Xhigh', max: 'Max', ultra: 'Ultra', thinking: 'Thinking' },
+});
+
+let _translate = null;
+let _locale = null;
+
+/**
+ * The page's translator, `(key, params) => t('schedules.view.' + key, params)`, and the app's locale
+ * (a code or a function that returns one). An answer that is empty, or the key itself (i18n's word for
+ * "no such string"), falls back to the English.
+ */
+export function setSchedulesViewTranslator(fn, locale = null) {
+  _translate = typeof fn === 'function' ? fn : null;
+  _locale = locale;
+}
+
+const copyAt = (key) => key.split('.').reduce((node, part) => node?.[part], SCHEDULES_VIEW_COPY);
+const fill = (text, params) => String(text).replace(/\{(\w+)\}/g, (whole, name) => (params?.[name] != null ? params[name] : whole));
+
+/** A SCHEDULES_VIEW_COPY sentence in the page's language (the translator above, else the English). */
+export function scheduleWord(key, params) {
+  if (_translate) {
+    try {
+      const text = _translate(key, params);
+      if (typeof text === 'string' && text && text !== key && text !== `schedules.view.${key}`) return text;
+    } catch { /* the English below */ }
+  }
+  const english = copyAt(key);
+  return typeof english === 'string' ? fill(english, params) : key;
+}
+
+/** A counted sentence: `key.one` for exactly one, `key.other` otherwise (i18n's tp rule). */
+const countWord = (key, count, params) => scheduleWord(`${key}.${count === 1 ? 'one' : 'other'}`, { count, ...params });
+
+/**
+ * The locale dates and times are written in. English keeps en-GB: the 24-hour clock and day-first dates
+ * ("Wed 22 Oct 09:00") the cron descriptions use. Any other language writes them its own way.
+ */
+export function scheduleDateLocale() {
+  const locale = typeof _locale === 'function' ? _locale() : _locale;
+  return !locale || /^en(-|$)/i.test(locale) ? 'en-GB' : locale;
+}
+
+const DAY_KEYS = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+
+/** A weekday (0 = Sunday … 6 = Saturday; 7 is Sunday too, as in cron): "Mon", or "Monday" with `long`. */
+export function weekdayName(index, { long = false } = {}) {
+  const key = DAY_KEYS[Number(index) % 7];
+  return key ? scheduleWord(`${long ? 'dayLong' : 'dayShort'}.${key}`) : '';
+}
+
 const pad = (n) => String(n).padStart(2, '0');
 const time = (t) => (Number.isFinite(t) ? t : NaN);
 const parse = (iso) => (iso ? time(Date.parse(iso)) : NaN);
 
-/** "a", "a and b", "a, b and c". */
+/** "a", "a and b", "a, b and c" (the last joint in the page's language). */
 export function listJoin(items) {
-  const list = items.filter(Boolean);
+  const list = items.filter(item => item || item === 0).map(String);
   if (list.length <= 1) return list.join('');
-  return `${list.slice(0, -1).join(', ')} and ${list.at(-1)}`;
+  return scheduleWord('listAnd', { list: list.slice(0, -1).join(', '), last: list.at(-1) });
 }
 
+/** The days of a cron's day-of-week field: `{ text, everyDay }`, or null when it cannot be said plainly. */
 function dayList(field) {
-  if (field === '*' || field === '?') return 'Every day';
-  if (field === '1-5') return 'Weekdays';
-  if (field === '0,6' || field === '6,0' || field === '6,7') return 'Weekends';
+  if (field === '*' || field === '?') return { text: scheduleWord('everyDay'), everyDay: true };
+  if (field === '1-5') return { text: scheduleWord('weekdays') };
+  if (field === '0,6' || field === '6,0' || field === '6,7') return { text: scheduleWord('weekends') };
   const parts = field.split(',');
   const names = [];
   for (const part of parts) {
     const range = part.match(/^(\d)-(\d)$/);
     if (range) {
-      const from = DAY_SHORT[+range[1] % 7], to = DAY_SHORT[+range[2] % 7];
+      const from = weekdayName(range[1]), to = weekdayName(range[2]);
       if (!from || !to) return null;
-      names.push(`${from}–${to}`);
+      names.push(scheduleWord('dayRange', { from, to }));
     } else if (/^\d$/.test(part)) {
-      names.push(DAY_SHORT[+part % 7]);
+      names.push(weekdayName(part));
     } else {
       return null;
     }
   }
-  return listJoin(names);
+  return { text: listJoin(names) };
 }
 
 function timesOf(minute, hour) {
   const m = /^\d{1,2}$/.test(minute) ? +minute : null;
-  if (minute === '*' && hour === '*') return { every: 'every minute' };
+  if (minute === '*' && hour === '*') return { every: countWord('everyMinutes', 1) };
   const minStep = minute.match(/^\*\/(\d+)$/);
-  if (minStep && hour === '*') return { every: `every ${minStep[1]} minutes` };
+  if (minStep && hour === '*') return { every: countWord('everyMinutes', +minStep[1]) };
   if (m == null) {
     // Several minutes in one hour: "at 09:00 and 09:30".
     if (/^\d{1,2}(,\d{1,2})+$/.test(minute) && /^\d{1,2}$/.test(hour)) {
@@ -61,15 +174,18 @@ function timesOf(minute, hour) {
     }
     return null;
   }
-  if (hour === '*') return { every: `every hour at :${pad(m)}` };
+  if (hour === '*') return { every: countWord('everyHoursAt', 1, { minute: pad(m) }) };
   const hourStep = hour.match(/^\*\/(\d+)$/);
-  if (hourStep) return { every: `every ${hourStep[1]} hours at :${pad(m)}` };
+  if (hourStep) return { every: countWord('everyHoursAt', +hourStep[1], { minute: pad(m) }) };
   const hourRange = hour.match(/^(\d{1,2})-(\d{1,2})$/);
-  if (hourRange) return { every: `every hour from ${pad(+hourRange[1])}:${pad(m)} to ${pad(+hourRange[2])}:${pad(m)}` };
+  if (hourRange) return { every: scheduleWord('everyHourBetween', { from: `${pad(+hourRange[1])}:${pad(m)}`, to: `${pad(+hourRange[2])}:${pad(m)}` }) };
   if (/^\d{1,2}(,\d{1,2})*$/.test(hour)) return { at: listJoin(hour.split(',').map(h => `${pad(+h)}:${pad(m)}`)) };
   return null;
 }
 
+// A sentence that starts with a phrase written for its middle ("every 15 minutes").
+const capitalize = (text) => text.charAt(0).toLocaleUpperCase(scheduleDateLocale()) + text.slice(1);
+
 /**
  * A five-field cron in plain words: "Every day at 06:55, 14:55 and 20:55", "Weekdays at 09:00",
  * "Every 15 minutes". Anything it cannot say plainly comes back as the expression itself.
@@ -84,13 +200,12 @@ export function describeCron(cron) {
   if (dom === '*' || dom === '?') days = dayList(dow);
   else if (dow === '*' && /^\d{1,2}(,\d{1,2})*$/.test(dom)) {
     const dates = dom.split(',').map(Number);
-    days = `${dates.length > 1 ? 'Days' : 'Day'} ${listJoin(dates)} of every month`;
+    days = { text: countWord('monthDays', dates.length, { days: listJoin(dates) }) };
   } else return expr;
   const times = timesOf(minute, hour);
   if (!days || !times) return expr;
-  if (times.at) return `${days} at ${times.at}`;
-  const every = times.every.charAt(0).toUpperCase() + times.every.slice(1);
-  return days === 'Every day' ? every : `${days}, ${times.every}`;
+  if (times.at) return scheduleWord('daysAt', { days: days.text, times: times.at });
+  return days.everyDay ? capitalize(times.every) : scheduleWord('daysEvery', { days: days.text, every: times.every });
 }
 
 /** One line of text from a run result: no newlines, no runs of spaces. */
@@ -104,17 +219,18 @@ export function oneLine(text) {
  */
 export function lastRunState(schedule) {
   const raw = schedule?.lastRunResult;
-  if (raw == null || raw === '') return { kind: 'never', label: 'Not run yet', reason: '' };
+  if (raw == null || raw === '') return { kind: 'never', label: scheduleWord('runNever'), reason: '' };
   const text = String(raw);
-  if (text === 'completed') return { kind: 'ok', label: 'Completed', reason: '' };
-  if (text === 'launched' || text === 'running' || text === 'started') return { kind: 'started', label: 'Started', reason: '' };
-  if (text === 'template_missing') return { kind: 'failed', label: 'Automation missing', reason: 'The automation this schedule launches no longer exists.' };
+  if (text === 'completed') return { kind: 'ok', label: scheduleWord('runCompleted'), reason: '' };
+  if (text === 'launched' || text === 'running' || text === 'started') return { kind: 'started', label: scheduleWord('runStarted'), reason: '' };
+  if (text === 'template_missing') return { kind: 'failed', label: scheduleWord('runAutomationMissing'), reason: scheduleWord('runAutomationMissingReason') };
+  // What follows the colon is the server's own message: it shows as it came.
   const colon = text.indexOf(':');
   const head = (colon >= 0 ? text.slice(0, colon) : text).trim();
   const reason = colon >= 0 ? text.slice(colon + 1).trim() : '';
-  if (head === 'error') return { kind: 'failed', label: 'Failed', reason: reason || 'The run failed.' };
-  if (head === 'stopped') return { kind: 'stopped', label: 'Stopped', reason: reason === 'user' ? 'Stopped by you' : reason };
-  if (head === 'interrupted') return { kind: 'interrupted', label: 'Interrupted', reason };
+  if (head === 'error') return { kind: 'failed', label: scheduleWord('runFailed'), reason: reason || scheduleWord('runFailedReason') };
+  if (head === 'stopped') return { kind: 'stopped', label: scheduleWord('runStopped'), reason: reason === 'user' ? scheduleWord('runStoppedByYou') : reason };
+  if (head === 'interrupted') return { kind: 'interrupted', label: scheduleWord('runInterrupted'), reason };
   return { kind: 'other', label: head.charAt(0).toUpperCase() + head.slice(1), reason };
 }
 
@@ -215,17 +331,17 @@ export function sortSchedules(list, sort = 'next') {
 /** "in 45 s", "in 26 min", "in 3 h 5 min", "in 2 d 4 h"; "Due now"; "Overdue". */
 export function formatCountdown(iso, now = Date.now()) {
   const next = parse(iso);
-  if (!Number.isFinite(next)) return { text: 'Not scheduled', state: 'none' };
+  if (!Number.isFinite(next)) return { text: scheduleWord('notScheduled'), state: 'none' };
   const diff = next - now;
-  if (diff <= 0) return diff > -OVERDUE_AFTER ? { text: 'Due now', state: 'due' } : { text: 'Overdue', state: 'overdue' };
-  if (diff < MINUTE) return { text: `in ${Math.ceil(diff / 1000)} s`, state: 'soon' };
-  if (diff < HOUR) return { text: `in ${Math.floor(diff / MINUTE)} min`, state: diff < 15 * MINUTE ? 'soon' : 'future' };
+  if (diff <= 0) return diff > -OVERDUE_AFTER ? { text: scheduleWord('dueNow'), state: 'due' } : { text: scheduleWord('overdue'), state: 'overdue' };
+  if (diff < MINUTE) return { text: scheduleWord('inSeconds', { n: Math.ceil(diff / 1000) }), state: 'soon' };
+  if (diff < HOUR) return { text: scheduleWord('inMinutes', { n: Math.floor(diff / MINUTE) }), state: diff < 15 * MINUTE ? 'soon' : 'future' };
   if (diff < DAY) {
     const h = Math.floor(diff / HOUR), m = Math.floor((diff % HOUR) / MINUTE);
-    return { text: m ? `in ${h} h ${m} min` : `in ${h} h`, state: 'future' };
+    return { text: m ? scheduleWord('inHoursMinutes', { h, m }) : scheduleWord('inHours', { h }), state: 'future' };
   }
   const d = Math.floor(diff / DAY), h = Math.floor((diff % DAY) / HOUR);
-  return { text: h ? `in ${d} d ${h} h` : `in ${d} d`, state: 'future' };
+  return { text: h ? scheduleWord('inDaysHours', { d, h }) : scheduleWord('inDays', { d }), state: 'future' };
 }
 
 /** "just now", "5 min ago", "2 h ago", "yesterday", "3 d ago". */
@@ -233,59 +349,77 @@ export function formatAgo(iso, now = Date.now()) {
   const then = parse(iso);
   if (!Number.isFinite(then)) return '';
   const diff = Math.max(0, now - then);
-  if (diff < MINUTE) return 'just now';
-  if (diff < HOUR) return `${Math.floor(diff / MINUTE)} min ago`;
-  if (diff < DAY) return `${Math.floor(diff / HOUR)} h ago`;
+  if (diff < MINUTE) return scheduleWord('justNow');
+  if (diff < HOUR) return scheduleWord('minutesAgo', { n: Math.floor(diff / MINUTE) });
+  if (diff < DAY) return scheduleWord('hoursAgo', { n: Math.floor(diff / HOUR) });
   const days = Math.floor(diff / DAY);
-  return days === 1 ? 'yesterday' : `${days} d ago`;
+  return days === 1 ? scheduleWord('yesterdayAgo') : scheduleWord('daysAgo', { n: days });
 }
 
 const sameDay = (a, b) => a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
-// The window's words are English, so are its dates: "Wed 22 Oct", never half in another language.
-const LOCALE = 'en-GB';
 
 /** "Today", "Tomorrow", "Yesterday" or the weekday and date, for a heading or a time. */
-export function dayLabel(iso, now = Date.now(), locale = LOCALE) {
+export function dayLabel(iso, now = Date.now(), locale = scheduleDateLocale()) {
   const then = new Date(parse(iso));
   if (Number.isNaN(then.getTime())) return '';
   const today = new Date(now);
-  if (sameDay(then, today)) return 'Today';
-  if (sameDay(then, new Date(now + DAY))) return 'Tomorrow';
-  if (sameDay(then, new Date(now - DAY))) return 'Yesterday';
+  if (sameDay(then, today)) return scheduleWord('today');
+  if (sameDay(then, new Date(now + DAY))) return scheduleWord('tomorrow');
+  if (sameDay(then, new Date(now - DAY))) return scheduleWord('yesterday');
   return then.toLocaleDateString(locale, { weekday: 'short', day: 'numeric', month: 'short' });
 }
 
 /** 24-hour clock, as the cron descriptions are: "14:55". */
-export function clockTime(iso, locale = LOCALE) {
+export function clockTime(iso, locale = scheduleDateLocale()) {
   const then = new Date(parse(iso));
   if (Number.isNaN(then.getTime())) return '';
   return then.toLocaleTimeString(locale, { hour: '2-digit', minute: '2-digit', hourCycle: 'h23' });
 }
 
 /** "Today 14:55", "Tomorrow 09:00", "Wed 22 Oct 09:00". */
-export function whenLabel(iso, now = Date.now(), locale = LOCALE) {
+export function whenLabel(iso, now = Date.now(), locale = scheduleDateLocale()) {
   const day = dayLabel(iso, now, locale);
   const clock = clockTime(iso, locale);
-  return day && clock ? `${day} ${clock}` : '';
+  return day && clock ? scheduleWord('dayAt', { day, time: clock }) : '';
 }
 
 /** A run time in the fewest words: "14:55" today, "Tomorrow 09:00", "Wed 09:00" this week, then "22 Oct". */
-export function shortWhen(iso, now = Date.now(), locale = LOCALE) {
+export function shortWhen(iso, now = Date.now(), locale = scheduleDateLocale()) {
   const at = parse(iso);
   if (!Number.isFinite(at)) return '';
   const then = new Date(at);
   const clock = clockTime(iso, locale);
   if (sameDay(then, new Date(now))) return clock;
-  if (sameDay(then, new Date(now + DAY))) return `Tomorrow ${clock}`;
-  if (at > now && at - now < 6 * DAY) return `${then.toLocaleDateString(locale, { weekday: 'short' })} ${clock}`;
+  if (sameDay(then, new Date(now + DAY))) return scheduleWord('tomorrowAt', { time: clock });
+  if (at > now && at - now < 6 * DAY) return scheduleWord('weekdayAt', { day: then.toLocaleDateString(locale, { weekday: 'short' }), time: clock });
   return then.toLocaleDateString(locale, { day: 'numeric', month: 'short' });
 }
 
+/** A date and time in full, for a tooltip: "22/10/2026, 14:55:03" in English, the locale's own way otherwise. */
+export function fullDateTime(iso, locale = scheduleDateLocale()) {
+  const then = new Date(parse(iso));
+  return Number.isNaN(then.getTime()) ? '' : then.toLocaleString(locale);
+}
+
+const capitalized = (value) => String(value).charAt(0).toUpperCase() + String(value).slice(1);
+
+/** A context choice in words: "1M tokens", "Extended"; one this file does not know reads as its id. */
+export function contextWord(value) {
+  if (value === '1m') return scheduleWord('context1m');
+  if (value === 'extended') return scheduleWord('contextExtended');
+  return capitalized(value);
+}
+
+/** A thinking level in words: "Low", "High"; one this file does not know reads as its id. */
+export function effortWord(value) {
+  return Object.prototype.hasOwnProperty.call(SCHEDULES_VIEW_COPY.effort, value) ? scheduleWord(`effort.${value}`) : capitalized(value);
+}
+
 /**
  * The launch settings a run will use and where each comes from: the schedule's own value wins,
- * then its group's, then the automation's. `labels` names CLIs (`profiles`) and MCP presets.
+ * then its group's, then the automation's. `labels` names CLIs (`profiles`) and tool groups.
  */
-export function launchFacts(schedule, { group = null, template = null, profiles = [], mcpLabels = {} } = {}) {
+export function launchFacts(schedule, { group = null, template = null, profiles = [], toolCatalog = null, translate } = {}) {
   const pick = (field) => {
     for (const [source, owner] of [['schedule', schedule], ['group', group], ['automation', template]]) {
       const value = owner?.[field];
@@ -296,23 +430,23 @@ export function launchFacts(schedule, { group = null, template = null, profiles
   const facts = [];
   const profile = pick('profile');
   const profileId = profile.value || 'claude-code';
-  facts.push({ key: 'profile', label: 'CLI', value: profiles.find(p => p.id === profileId)?.label || profileId, source: profile.value ? profile.source : 'default' });
+  facts.push({ key: 'profile', label: scheduleWord('factCli'), value: profiles.find(p => p.id === profileId)?.label || profileId, source: profile.value ? profile.source : 'default' });
   const model = pick('model');
-  facts.push({ key: 'model', label: 'Model', value: model.value || 'Default', source: model.source, mono: !!model.value });
+  facts.push({ key: 'model', label: scheduleWord('factModel'), value: model.value || scheduleWord('valueDefault'), source: model.source, mono: !!model.value });
   const context = pick('contextMode');
-  if (context.value && context.value !== 'default') facts.push({ key: 'contextMode', label: 'Context', value: context.value === '1m' ? '1M tokens' : context.value.charAt(0).toUpperCase() + context.value.slice(1), source: context.source });
+  if (context.value && context.value !== 'default') facts.push({ key: 'contextMode', label: scheduleWord('factContext'), value: contextWord(context.value), source: context.source });
   const effort = pick('effort');
-  if (effort.value && effort.value !== 'off') facts.push({ key: 'effort', label: 'Thinking', value: effort.value.charAt(0).toUpperCase() + effort.value.slice(1), source: effort.source });
-  const mcp = pick('mcpProfile');
+  if (effort.value && effort.value !== 'off') facts.push({ key: 'effort', label: scheduleWord('factThinking'), value: effortWord(effort.value), source: effort.source });
+  const mcp = pick('tools');
   if (mcp.value) {
-    const value = mcpLabels[mcp.value] || String(mcp.value).split(',').map(x => x.trim()).filter(Boolean).join(', ');
-    facts.push({ key: 'mcpProfile', label: 'MCP tools', value, source: mcp.source });
+    const value = toolCatalog ? toolListView(toolCatalog, mcp.value, { translate }).summary : mcp.value.filter(id => !id.startsWith('mcp:')).join(', ') || scheduleWord('valueDefault');
+    facts.push({ key: 'tools', label: scheduleWord('factMcp'), value, source: mcp.source });
   }
   if (profileId === 'codex') {
     const account = pick('codexAccountId');
-    if (account.value) facts.push({ key: 'codexAccountId', label: 'OpenAI account', value: account.value, source: account.source });
+    if (account.value) facts.push({ key: 'codexAccountId', label: scheduleWord('factAccount'), value: account.value, source: account.source });
   }
   const browser = pick('usesBrowser');
-  facts.push({ key: 'usesBrowser', label: 'Browser', value: browser.value === true ? 'On' : 'Off', source: browser.source });
+  facts.push({ key: 'usesBrowser', label: scheduleWord('factBrowser'), value: scheduleWord(browser.value === true ? 'valueOn' : 'valueOff'), source: browser.source });
   return facts;
 }

package/neural-interface/public/shared/settings/settings-claude-hooks.js

@@ -0,0 +1,135 @@
+// ═══════════════════════════════════════════
+// SETTINGS — SynaBun's Claude Code hooks, in words
+// ═══════════════════════════════════════════
+//
+// What `GET /api/claude-code/integrations` says in `claudeHooks` (lib/claude-hooks-status.js) about Settings →
+// Automations → Automation behavior → SynaBun hooks in Claude Code: whether a Claude Code session the owner starts
+// by themselves runs SynaBun's hooks, what stands in the way, and whether the switch can change it. Pure: no DOM
+// and no import, so node runs it (tests/settings-claude-hooks-view.test.mjs).
+//
+//   readClaudeHooksResponse({ status, body, error })   what the server answered → a reading
+//   describeClaudeHooks(reading, { tx })                the row as ui-settings.js draws it
+//   describeClaudeHooksSaveFailure(input, { tx })       the sentence for a change that could not be made
+//
+// `tx(key, params)` is the caller's translate function over the settings.redesign.* strings (the kit's `tx`).
+// The row never shows "off" for what it could not read: a refusal (SynaBun's automation browser), a server started
+// before this, an unreadable settings file each say what they are, with the switch disabled.
+
+const K = 'settings.redesign.hooks.claudeHooks';
+
+/** The rows of the "Hooks for standalone Claude Code" list: one per moment, the guards over two events. */
+export const CLAUDE_HOOK_ROWS = Object.freeze([
+  Object.freeze({ key: 'SessionStart', events: ['SessionStart'] }),
+  Object.freeze({ key: 'UserPromptSubmit', events: ['UserPromptSubmit'] }),
+  Object.freeze({ key: 'PreCompact', events: ['PreCompact'] }),
+  Object.freeze({ key: 'Stop', events: ['Stop'] }),
+  Object.freeze({ key: 'PreToolUse', events: ['PreToolUse', 'PostToolBatch'] }),
+  Object.freeze({ key: 'PostToolUse', events: ['PostToolUse'] }),
+  Object.freeze({ key: 'SubagentStart', events: ['SubagentStart'] }),
+  Object.freeze({ key: 'SubagentStop', events: ['SubagentStop'] }),
+]);
+
+/** The refusals of SynaBun's owner-only routes for a browser that is not the owner's (lib/owner-authority.js). */
+const REFUSED_CODES = new Set(['WORKER_BROWSER', 'PEER_REFUSED']);
+
+const clean = (value, max = 240) => {
+  const text = String(value ?? '').replace(/\s+/g, ' ').trim();
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+};
+const names = (list) => [...new Set((list || []).map((p) => clean(p.label || String(p.path || '').split(/[\\/]/).filter(Boolean).pop() || p.path, 60)))].join(', ');
+
+/**
+ * What the server answered.
+ *
+ *   ready        `hooks` is the server's claudeHooks
+ *   old-server   an answer without claudeHooks: the running server was started before it (public/ is served live,
+ *                lib/ only after a restart), and its own reading of the settings may be wrong
+ *   refused      403 WORKER_BROWSER / PEER_REFUSED: SynaBun's automation browser, never the owner's own window
+ *   forbidden    403 otherwise (a guest)
+ *   unreadable   anything else (no answer, an error, a body that is not the payload)
+ */
+export function readClaudeHooksResponse({ status = 0, body = null, error = null } = {}) {
+  const code = Number(status) || 0;
+  if (code >= 200 && code < 300 && body && typeof body === 'object' && body.ok === true) {
+    const hooks = body.claudeHooks;
+    if (hooks && typeof hooks === 'object' && Number(hooks.version) >= 1 && typeof hooks.state === 'string') return { state: 'ready', hooks, reason: null };
+    return { state: 'old-server', hooks: null, reason: null };
+  }
+  if (code === 403) {
+    const refusal = String(body?.code || '');
+    return { state: REFUSED_CODES.has(refusal) ? 'refused' : 'forbidden', hooks: null, reason: clean(body?.error) || null, code: refusal || null };
+  }
+  return { state: 'unreadable', hooks: null, reason: clean(error || body?.error || (code ? `HTTP ${code}` : '')) || null };
+}
+
+/** Which list rows are on: every event of the row has all of SynaBun's handlers. */
+export function claudeHookRowsOn(events) {
+  return Object.fromEntries(CLAUDE_HOOK_ROWS.map((row) => [row.key, row.events.every((event) => events?.[event] === true)]));
+}
+
+/**
+ * The row: { state, ready, disabled, on, notes: [{ text, tone }], note: { text, tone } | null, repair, applies,
+ * rows: { [rowKey]: boolean } | null (the list below; null when nothing could be read), onRows, totalRows }.
+ * `note` says why nothing below can be trusted or changed; `notes` describe what is installed.
+ */
+export function describeClaudeHooks(reading, { tx }) {
+  const r = reading || readClaudeHooksResponse({ status: 0 });
+  const view = { state: r.state, ready: false, disabled: true, on: false, notes: [], note: null, repair: false, applies: tx(`${K}.applies`), rows: null, onRows: 0, totalRows: CLAUDE_HOOK_ROWS.length };
+  if (r.state === 'old-server') { view.note = { text: tx(`${K}.restart`), tone: 'warn' }; return view; }
+  if (r.state === 'refused') { view.note = { text: tx(`${K}.refused`), tone: 'warn' }; return view; }
+  if (r.state === 'forbidden') { view.note = { text: tx(`${K}.forbidden`), tone: 'warn' }; return view; }
+  if (r.state !== 'ready') {
+    view.note = { text: r.reason ? tx(`${K}.unreadable`, { reason: r.reason }) : tx(`${K}.unreadableNoReason`), tone: 'warn' };
+    return view;
+  }
+  const h = r.hooks;
+  if (h.state === 'error') {
+    view.note = { text: tx(`${K}.settingsUnreadable`, { path: h.settingsPath || '~/.claude/settings.json', reason: clean(h.error) || '?' }), tone: 'warn' };
+    return view;
+  }
+  const path = h.settingsPath || '~/.claude/settings.json';
+  const rows = claudeHookRowsOn(h.events);
+  const onRows = Object.values(rows).filter(Boolean).length;
+  const installed = h.state === 'on' || h.state === 'partial';
+  const managed = h.blockedBy?.scope === 'managed';
+  view.ready = true;
+  view.rows = rows;
+  view.onRows = onRows;
+  // On means "a session the owner starts runs them": installed and not switched off by Claude Code itself.
+  view.on = installed && !h.blockedBy;
+  // The organization's managed settings, and a packaged app started from a temporary place, cannot be switched here.
+  view.disabled = managed || !!h.installBlocker;
+
+  if (h.installBlocker) view.notes.push({ text: clean(h.installBlocker, 400), tone: 'warn' });
+  if (managed) view.notes.push({ text: tx(`${K}.blocked.managed.${h.blockedBy.setting === 'allowManagedHooksOnly' ? 'managedOnly' : 'disableAll'}`, { path: h.blockedBy.path }), tone: 'warn' });
+  else if (h.blockedBy) view.notes.push({ text: tx(`${K}.blocked.user`, { path: h.blockedBy.path || path }), tone: 'warn' });
+  else if (h.state === 'on') view.notes.push({ text: tx(`${K}.on`, { path }), tone: 'info' });
+  else if (h.state === 'partial') view.notes.push({ text: tx(`${K}.partial`, { on: onRows, total: CLAUDE_HOOK_ROWS.length }), tone: 'info' });
+  else view.notes.push({ text: tx(`${K}.off`), tone: 'info' });
+
+  if (h.needsRepair && !managed) {
+    view.repair = !h.installBlocker;
+    if (h.current < h.installed) view.notes.push({ text: tx(`${K}.repair.stale`, { count: h.installed - h.current }), tone: 'warn' });
+    if (h.duplicates > 0) view.notes.push({ text: tx(`${K}.repair.duplicates`, { count: h.duplicates }), tone: 'warn' });
+    const different = (h.projects || []).filter((p) => p.issue === 'different');
+    if (different.length) view.notes.push({ text: tx(`${K}.repair.projects`, { names: names(different) }), tone: 'warn' });
+    if (h.nodeMissing) view.notes.push({ text: tx(`${K}.repair.node`), tone: 'warn' });
+  }
+  const off = (h.projects || []).filter((p) => p.issue === 'disableAllHooks');
+  if (off.length) view.notes.push({ text: tx(`${K}.projectsOff`, { names: names(off) }), tone: 'warn' });
+  const stillOn = (h.projects || []).filter((p) => p.issue === 'project-only');
+  if (stillOn.length) view.notes.push({ text: tx(`${K}.projectsStillOn`, { names: names(stillOn) }), tone: 'warn' });
+  return view;
+}
+
+/**
+ * The sentence for a change that could not be made: { action: 'on' | 'off' | 'repair', status, body, error }.
+ * An answer without claudeHooks after a change that worked is a server started before this (said as such).
+ */
+export function describeClaudeHooksSaveFailure({ action = 'on', status = 0, body = null, error = null } = {}, { tx }) {
+  const verb = ['on', 'off', 'repair'].includes(action) ? action : 'on';
+  const code = Number(status) || 0;
+  if (!code) return tx(`${K}.save.noAnswer.${verb}`);
+  if (code === 403 && REFUSED_CODES.has(String(body?.code || ''))) return tx(`${K}.save.refused.${verb}`);
+  return tx(`${K}.save.failed.${verb}`, { reason: clean(body?.error || error) || `HTTP ${code}` });
+}

package/neural-interface/public/shared/settings/settings-data.js

@@ -21,7 +21,8 @@ const okBody = (body) => !!body && typeof body === 'object' && body.ok !== false
 export const SETTINGS_READS = Object.freeze({
   settings: { url: '/api/settings', accept: okBody },
   connections: { url: '/api/connections', accept: (body) => Array.isArray(body?.connections) },
-  integrations: { url: '/api/claude-code/integrations', accept: (body) => body?.ok === true },
+  // Raw: the hooks' row tells a refusal, an old server and an unreadable file apart (settings-claude-hooks.js).
+  integrations: { url: '/api/claude-code/integrations', raw: true },
   skills: { url: '/api/claude-code/skills', accept: (body) => body?.ok === true },
   // The tunnel changes by itself (starting, stopping from the Share menu): asked again after a few seconds.
   tunnel: { url: '/api/tunnel/status', accept: (body) => body?.ok === true, ttlMs: 10_000 },
@@ -38,6 +39,7 @@ export const SETTINGS_READS = Object.freeze({
   youtube: { url: '/api/youtube/config', accept: (body) => body?.ok === true },
   typesafe: { url: '/api/typesafe/config', accept: (body) => body?.ok === true },
   userContext: { url: '/api/assistant/user-context', raw: true },
+  workerGuard: { url: '/api/assistant/worker-guard', raw: true },
 });
 
 const caches = Object.fromEntries(Object.entries(SETTINGS_READS).map(([name, spec]) => [name, createDataCache(`settings:${name}`, {

package/neural-interface/public/shared/settings/settings-ia.js

@@ -103,7 +103,7 @@ export const SETTINGS_PAGES = [
     id: 'connected-tools', key: 'connected_tools', group: 'tools', icon: 'mcp',
     panes: [{ id: 'mcp' }, { id: 'morelogin', titleKey: k('pane.morelogin') }],
     sections: [
-      { id: 'stg-sec-tool-profiles',  key: 'tool_profiles',         state: 'open' },
+      { id: 'stg-sec-default-tools',  key: 'default_tools',         state: 'open' },
       { id: 'stg-sec-added-servers',  key: 'added_servers',         state: 'open' },
       { id: 'stg-sec-ml-connection',  key: 'morelogin_connection',  state: 'open' },
       { id: 'stg-sec-ml-profiles',    key: 'morelogin_profiles',    state: 'open' },
@@ -253,7 +253,7 @@ export const SETTINGS_CONTROLS = {
   'stg-sec-manual-setup': 'SET029 SET030 SET031 SET032',
   'cc-cli-paths': 'CLI001 CLI002 CLI007 CLI003 CLI004 CLI005 CLI006',
   'stg-sec-opencode-service': 'OCP001 OCP002 OCP003 OCP004 OCP005 OCP021 OCP022 OCP019',
-  'stg-sec-opencode-behavior': 'OCP013 OCP014 OCP015 OCP016',
+  'stg-sec-opencode-behavior': 'OCP013 OCP015 OCP016',
   'stg-sec-opencode-tools': 'OCP017',
   'stg-sec-opencode-history': 'OCP023 OCP018',
   'stg-sec-database': 'GEN015 GEN001 GEN002 GEN003 GEN016 GEN004 GEN005 GEN006 GEN017 DB003',
@@ -268,18 +268,18 @@ export const SETTINGS_CONTROLS = {
   'bcg-identity': 'BRW021 BRW022 BRW023 BRW024 BRW025',
   'bcg-viewport': 'BRW026 BRW027 BRW028 BRW029 BRW030 BRW031 BRW032',
   'bcg-advanced': 'BRW033 BRW034 BRW035 BRW036 BRW037 BRW038 BRW039 BRW040 BRW041 BRW042 BRW043 BRW044 BRW045 BRW046 BRW047 BRW048 BRW049 BRW050 BRW051 BRW052 BRW053 BRW054 BRW055 BRW056 BRW057 BRW058 BRW059 BRW060 BRW061 BRW062 BRW063 BRW064 BRW065 BRW066 BRW067 BRW068 BRW069 BRW070 BRW071 BRW072 BRW073 BRW074 BRW075 BRW076 BRW077 BRW078 BRW079 BRW080',
-  'stg-sec-tool-profiles': 'MCP022 MCP024',
+  'stg-sec-default-tools': 'MCP022 MCP024 MCP005 MCP004',
   'stg-sec-added-servers': 'MCP026 MCP006 MCP007 MCP008 MCP009 MCP010 MCP011 MCP012 MCP013 MCP014 MCP015 MCP027 MCP016 MCP017 MCP018 MCP019 MCP020 MCP021',
   'stg-sec-ml-connection': 'ML015 ML001 ML002 ML003',
   'stg-sec-ml-profiles': 'ML004 ML005 ML006 ML016 ML017 ML018 ML019',
   'stg-sec-ml-credentials': 'ML007 ML008 ML009 ML010 ML011',
   'stg-sec-ml-server': 'ML012 ML013 ML014',
   'stg-sec-skills': 'SKL004 SKL001',
-  'stg-sec-tool-permissions': 'PER012 PER001 PER002 PER003 PER004 PER005 PER006 PER007 PER008 PER009 PER010 PER011',
+  'stg-sec-tool-permissions': 'PER012 PER001 PER002 PER003 PER004 PER005 PER006 PER008 PER009 PER010 PER011',
   'stg-sec-editor-editing': 'EDT014 EDT015 EDT016 EDT017 EDT018 EDT019 EDT020 EDT021 EDT022 EDT023',
   'stg-sec-editor-ai': 'EDT001 EDT002 EDT003 EDT004 EDT005 EDT006 EDT007 EDT008 EDT009 EDT010 EDT011 EDT012 EDT013',
   'stg-sec-greetings': 'AUT058 AUT059 AUT060',
-  'stg-sec-automation-behavior': 'AUT053 AUT054 AUT055 AUT056 AUT057 AUT046 AUT036 AUT037 AUT038 AUT039 AUT040 AUT041 AUT028 AUT029 AUT030 AUT031 AUT032 AUT033 AUT034 AUT035',
+  'stg-sec-automation-behavior': 'AUT053 AUT054 AUT055 AUT061 AUT062 AUT056 AUT057 AUT046 AUT036 AUT037 AUT038 AUT039 AUT040 AUT041 AUT028 AUT029 AUT030 AUT031 AUT032 AUT033 AUT034 AUT035',
   'stg-sec-online-access': 'AUT048 AUT042 AUT043 AUT044 AUT045 AUT049 AUT050 AUT051 AUT052',
   'stg-sec-social': 'SOC003 SOC001 SOC002',
   'stg-sec-youtube': 'YT017 YT001 YT002 YT003 YT004 YT005 YT006 YT007 YT008 YT009 YT010 YT011 YT012 YT013 YT014 YT015 YT016 YT018',
@@ -349,7 +349,7 @@ export const SETTINGS_TAB_ALIASES = {
   judgments:     { page: 'ai-decisions',    section: 'jv-sec-connection' },
   projects:      { page: 'projects',        section: 'stg-sec-workspaces' },
   browser:       { page: 'browser',         section: 'setup-browser' },
-  mcp:           { page: 'connected-tools', section: 'stg-sec-tool-profiles' },
+  mcp:           { page: 'connected-tools', section: 'stg-sec-default-tools' },
   morelogin:     { page: 'connected-tools', section: 'stg-sec-ml-connection' },
   skills:        { page: 'tool-access',     section: 'stg-sec-skills' },
   permissions:   { page: 'tool-access',     section: 'stg-sec-tool-permissions' },