@agentwhy/cli 0.0.0-dev

package/dist/report/start/to-fix/to-fix-renderer.js

@@ -0,0 +1,237 @@
+import { matchesGlob } from '../../../core/policy/glob.js';
+import { idInKey } from '../../../core/session-catalogue.js';
+import { escapeHtml as e } from '../../render/html-report-components.js';
+import { INDEX_CONTENT_SECURITY_POLICY_META } from '../../render/html-head.js';
+import { inLanguages, LANGS, translator } from '../../render/report-copy.js';
+import { FIX_WIZARD_SCRIPT } from '../../render/report-page/fix-wizard-script.js';
+import { FIX_WIZARD_STYLE } from '../../render/report-page/fix-wizard.js';
+import { HELPERS_SCRIPT, HELPERS_VIEW_STYLE } from '../../render/report-page/helpers-view.js';
+import { STORY_WINDOW_STYLE } from '../../render/report-page/story-window.js';
+import { clockIn } from '../../render/report-page/times.js';
+import { AVATAR_STYLE } from '../../render/ui/avatar.js';
+import { STAT_STYLE } from '../../render/ui/stats.js';
+import { appSidebar, APP_SIDEBAR_STYLE } from '../../render/ui/app-sidebar.js';
+import { ASK_PANEL_SCRIPT, ASK_PANEL_STYLE } from '../../render/ui/ask-panel.js';
+import { CHECKLIST_SCRIPT, CHECKLIST_STYLE } from '../../render/ui/checklist.js';
+import { BUTTON_STYLE } from '../../render/ui/button.js';
+import { CALLOUT_STYLE } from '../../render/ui/callout.js';
+import { CONFIRM_DIALOG_STYLE } from '../../render/ui/confirm-dialog.js';
+import { dataTable, DATA_TABLE_STYLE } from '../../render/ui/data-table.js';
+import { fileChips, FILE_CHIP_SCRIPT, FILE_CHIP_STYLE } from '../../render/ui/file-chip.js';
+import { FOLD_LINE_STYLE } from '../../render/ui/fold-line.js';
+import { hero, HERO_STYLE } from '../../render/ui/hero.js';
+import { localClock, rangeName } from '../../render/ui/local-date.js';
+import { pageShell } from '../../render/ui/page-shell.js';
+import { pillTabs, PILL_TABS_SCRIPT, PILL_TABS_STYLE } from '../../render/ui/pill-tabs.js';
+import { POPUP_SCRIPT, POPUP_STYLE } from '../../render/ui/popup.js';
+import { PROGRESS_STYLE } from '../../render/ui/progress.js';
+import { TAG_STYLE } from '../../render/ui/tag.js';
+import { TASK_LIST_STYLE } from '../../render/ui/task-list.js';
+import { LABELS } from '../../check/render/text-digest-renderer.js';
+import { appNav, sidebarProject } from '../app-nav.js';
+import { projectsWindows } from '../projects/projects-window.js';
+import { doneList, undoWindows } from './done-list.js';
+import { fixWindow, happenedWindow } from './file-window.js';
+import { TO_FIX_SCRIPT } from './to-fix-script.js';
+import { toFixList } from './to-fix-list.js';
+import { toFixView } from './to-fix-view.js';
+import { pageNotice } from '../page-notice.js';
+/**
+ * To fix, written as `to-fix.html` beside the index (`.ai/specs/2026-09-23-to-fix.md`; design file *agentwhy To fix*;
+ * `.ai/plans/2026-09-23-to-fix-redesign.md`): every file still to fix across the run's conversations, what to do about
+ * each, and what was done. Every mark and every undo goes through the server, and the page is read again (R60).
+ */
+export class ToFixRenderer {
+    #links;
+    constructor(links) {
+        this.#links = links;
+    }
+    render(index) {
+        const view = toFixView(index);
+        // A shared page writes nothing and carries no note (T19, R37).
+        const writable = !index.shared;
+        // Each file with its group, in the order the page draws them: the window's number is its place here.
+        const files = [...view.keys.map((file) => ({ file, kind: 'keys' })), ...view.look.map((file) => ({ file, kind: 'look' }))];
+        const numbered = new Map(files.map(({ file }, at) => [file, at]));
+        // F57: files the person chose only to be told about, so a file's Fix it does not offer to protect what they let through.
+        const toldPatterns = [index.settings?.told?.local, index.settings?.told?.shared].flatMap((list) => (list === undefined || list === 'unreadable' ? [] : list));
+        const told = new Set(files.map(({ file }) => file.item.path).filter((path) => toldPatterns.some((pattern) => matchesGlob(path, pattern))));
+        const windows = { writable, since: index.asked, settings: this.#links.settings, clock: clockIn(index.timeZone), told };
+        const done = writable ? view.done : view.done.map(({ note: _note, ...rest }) => rest);
+        return pageShell({
+            // which-project V2, V11: the person's projects, opened from the sidebar's card.
+            windows: projectsWindows(index),
+            title: 'fix.title',
+            // nothing-updates-by-itself U4: the update notice, where the project's hooks run an older release.
+            ...pageNotice(index),
+            policy: INDEX_CONTENT_SECURITY_POLICY_META,
+            width: 'list',
+            styles: [APP_SIDEBAR_STYLE, HERO_STYLE, BUTTON_STYLE, PILL_TABS_STYLE, TASK_LIST_STYLE, TAG_STYLE, CALLOUT_STYLE, FOLD_LINE_STYLE,
+                FILE_CHIP_STYLE, DATA_TABLE_STYLE, POPUP_STYLE, CONFIRM_DIALOG_STYLE, PROGRESS_STYLE, CHECKLIST_STYLE, ASK_PANEL_STYLE, FIX_WIZARD_STYLE, AVATAR_STYLE, STAT_STYLE,
+                // The story's Diagram is drawn with the Helpers diagram's boxes and lines, and lit by its script, as on the report.
+                HELPERS_VIEW_STYLE, STORY_WINDOW_STYLE, TO_FIX_STYLE],
+            scripts: [PILL_TABS_SCRIPT, POPUP_SCRIPT, CHECKLIST_SCRIPT, FILE_CHIP_SCRIPT, ASK_PANEL_SCRIPT, FIX_WIZARD_SCRIPT, HELPERS_SCRIPT, TO_FIX_SCRIPT],
+            sidebar: appSidebar({
+                ...sidebarProject(index),
+                home: this.#links.conversations,
+                items: appNav(index, 'to-fix', this.#links),
+            }),
+            main: '<div class="tf" data-to-fix data-fix-words="' + e(JSON.stringify(scriptWords())) + '">' +
+                hero({
+                    eyebrow: inLanguages((t, lang) => eyebrow(index, t, lang)),
+                    fact: inLanguages((t) => (view.total === 0 ? t('fix.hero.none') : t('fix.hero.count', { n: view.total }))),
+                    action: inLanguages((t) => (view.state === 'keys' ? t('fix.hero.keys', { n: view.keys.length }) : view.state === 'look' ? t('fix.hero.look') : t('fix.hero.nice'))),
+                    lead: inLanguages((t) => t('fix.lead')),
+                    calm: view.state === 'none',
+                }) +
+                pillTabs([
+                    { label: tabLabel('fix.tab.todo', view.total), panel: toFixList(view, numbered) },
+                    { label: tabLabel('fix.tab.done', done.length), panel: doneList(done, writable) },
+                ], 'state', 0, view.refusedAttempts === 0 ? '' :
+                    '<span class="tf-stopped"><span class="tf-stopped-mark" aria-hidden="true">✓</span>' +
+                        inLanguages((t) => t('fix.stopped', { n: view.refusedAttempts })) + '</span>') +
+                developer(view, index) +
+                files.map(({ file, kind }, at) => happenedWindow(file, kind, at, windows) + fixWindow(files.map((each) => each.file), at, windows)).join('') +
+                (writable ? undoWindows(done) : '') +
+                // The wizard's words; whether the page is served is known only to its address (T17).
+                '<div id="wizard-words" data-served="auto" hidden>' + ['wz.all', 'wz.finish', 'wz.saving', 'wz.tickFirst', 'wz.pickFirst']
+                .map((key) => '<span data-word="' + key + '">' + inLanguages((t) => t(key)) + '</span>').join('') + '</div>' +
+                '</div>',
+        });
+    }
+}
+/** "To fix 5", the count beside the word, as the design draws the two tabs. */
+function tabLabel(key, n) {
+    return inLanguages((t) => t(key)) + ' <span class="tf-tab-count">' + n + '</span>';
+}
+/** T2, D3: the run's range - "Last 30 days · Aug 25 – Sep 23", or "Since Sep 1" for a date. */
+function eyebrow(index, t, lang) {
+    const clock = localClock(index.timeZone ?? 'UTC');
+    const dates = rangeName(clock(index.since).day, clock(index.now).day, lang);
+    const span = /^(\d+)([hdw])$/.exec(index.asked);
+    return span === null
+        ? t('fix.range.since', { dates })
+        : t('fix.range', { range: t('fix.span.' + span[2], { n: Number(span[1]) }), dates });
+}
+/** T16: the conversations a row names before "+N more" - two, as a cell names at most two files (guidelines §9.1). */
+const SHOWN_IDS = 2;
+/**
+ * T16: the tool's own words, for a developer: what `check` says of each file with what the label means, the
+ * conversations it says it of, and the commands, each with what it does. A row of bare ids read as leaked values.
+ */
+function developer(view, index) {
+    const files = [...view.keys, ...view.look, ...view.seen];
+    const say = (key) => inLanguages((t) => t(key));
+    return '<details class="tf-dev"><summary class="tf-dev-toggle">' + say('fix.dev') + '</summary>' +
+        '<div class="tf-dev-body"><p class="tf-dev-lead">' + say(index.shared ? 'fix.dev.lead.shared' : 'fix.dev.lead') + '</p>' +
+        (files.length === 0 ? '' : dataTable({
+            head: [say('fix.dev.col.says'), say('fix.dev.col.file'), say('fix.dev.col.in')],
+            columns: 'minmax(150px,1fr) minmax(140px,1fr) minmax(220px,1.4fr)',
+            minWidth: 560,
+            rows: files.map((file) => ({
+                cells: [
+                    '<span class="tf-dev-label">' + LABELS[file.label] + '</span><span class="tf-dev-means">' + say('fix.dev.means.' + file.label) + '</span>',
+                    fileChips([file.path], 1),
+                    '<span class="tf-dev-count">' + inLanguages((t) => t('fix.dev.count', { n: file.count })) + '</span>' +
+                        fileChips(file.conversations.map((each) => each.entry.name), SHOWN_IDS, shortId),
+                ],
+            })),
+        })) +
+        '<div class="tf-dev-commands"><h3 class="tf-dev-h">' + say('fix.dev.commands') + '</h3>' +
+        command('fix.dev.cmd.full', 'agentwhy check --full --since ' + e(index.asked)) +
+        command('fix.dev.cmd.mark', 'agentwhy check --mark rotated &lt;path&gt;') + '</div></div></details>';
+}
+/**
+ * A session id is a UUID; its first 8 characters tell a run's conversations apart, and the chip's tooltip holds all of it.
+ * They are cut from the id, not the key, which for Codex starts with `codex-`.
+ */
+function shortId(name) {
+    const id = idInKey(name);
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-/i.test(id) ? id.slice(0, 8) : name;
+}
+/** One command, under what it does. `line` is already escaped. */
+function command(key, line) {
+    return '<div class="tf-dev-command"><span class="tf-dev-does">' + inLanguages((t) => t(key)) + '</span><code>' + line + '</code></div>';
+}
+/** What the script says, in every language: one text node cannot hold three. */
+function scriptWords() {
+    return Object.fromEntries(LANGS.map((lang) => {
+        const t = translator(lang);
+        return [lang, { saving: t('fix.saving'), refused: t('fix.refused'), asFile: t('fix.asFile'), unreachable: t('fix.unreachable') }];
+    }));
+}
+/** What only this page lays out. Colours come from the tokens (plan rule 1). */
+const TO_FIX_STYLE = String.raw `
+.tf-stopped{display:inline-flex;align-items:center;gap:10px;font-size:14px;font-weight:600;color:var(--mint);background:var(--mint-06);border:1px solid var(--mint-35);border-radius:999px;padding:7px 16px 7px 8px}
+.tf-stopped-mark{width:20px;height:20px;border-radius:50%;background:var(--mint);color:var(--on-mint);font-size:11px;font-weight:700;display:flex;align-items:center;justify-content:center}
+.tf-tab-count{margin-left:6px;font-size:13px;opacity:.7}
+.tf-group{margin-bottom:28px}
+.tf-group-head{display:flex;align-items:center;gap:10px;margin-bottom:6px}
+.tf-dot{width:10px;height:10px;border-radius:50%}
+.tf-group-coral .tf-dot{background:var(--coral)}.tf-group-amber .tf-dot{background:var(--amber)}
+.tf-h2{margin:0;font-size:20px;font-weight:650}
+.tf-group-count{font-size:15px;font-weight:650}
+.tf-group-coral .tf-group-count{color:var(--coral-text)}.tf-group-amber .tf-group-count{color:var(--amber)}
+.tf-group-lead{margin:0 0 14px 20px;font-size:14.5px;line-height:1.5;color:var(--text-2)}
+.tf-empty{font-size:15px;color:var(--text-2);margin:8px 0 24px}
+.tf-soft{color:var(--text-2);font-weight:400}
+.tf-context{font-size:13.5px;color:var(--text-3)}
+.tf-seen{list-style:none;margin:10px 0 0;padding:0;display:flex;flex-direction:column;gap:8px}
+.tf-seen-row{display:flex;align-items:center;gap:14px;padding:14px 20px;border-radius:14px;background:var(--card);border:1px solid var(--white-07)}
+.tf-seen-text{flex:1;min-width:0}
+.tf-seen-title{display:block;font-size:15px;font-weight:600}
+.tf-seen-sub{display:flex;align-items:center;gap:10px;margin-top:6px;flex-wrap:wrap}
+.tf-seen-label{font-size:13px;color:var(--text-3);white-space:nowrap}
+.tf-done-lead{font-size:14.5px;color:var(--text-2);margin:0 0 14px}
+.tf-done{list-style:none;margin:0;padding:0;display:flex;flex-direction:column;gap:10px}
+.tf-done-row{display:grid;grid-template-columns:minmax(0,1fr) auto auto;gap:18px;align-items:center;padding:16px 20px;border-radius:14px;background:var(--card);border:1px solid var(--mint-20)}
+.tf-done-title{display:block;font-size:15.5px;font-weight:600;color:var(--text-3)}
+.tf-done-sub{display:flex;align-items:center;gap:10px;margin-top:6px;flex-wrap:wrap}
+.tf-note{font-size:13.5px;color:var(--text-2);font-style:italic}
+.tf-fixed{font-size:13.5px;font-weight:600;color:var(--mint);white-space:nowrap}
+.tf-undo{color:var(--text-3);font-size:13.5px;font-weight:400}.tf-undo:hover{color:var(--coral-text)}
+.tf-window-head{padding:26px 32px 20px;border-bottom:1px solid var(--white-07)}
+.tf-window-top{display:flex;justify-content:space-between;align-items:center;gap:16px}
+.tf-window-group{font-size:14px;font-weight:600}.tf-window-keys{color:var(--coral-text)}.tf-window-look{color:var(--amber)}
+.tf-window-title{margin:6px 0 10px;font-size:24px;line-height:1.25;font-weight:650}
+.tf-window-body{display:flex;flex-direction:column;gap:22px;padding:24px 32px 28px}
+.tf-fact-text{margin:0;font-size:15px;line-height:1.55;color:var(--text-2)}
+.tf-h3{margin:0 0 12px;font-size:16px;font-weight:650}
+.tf-say{margin:10px 0 0;font-size:13.5px;line-height:1.5;color:var(--coral-text)}
+.tf-say[hidden]{display:none}
+.tf-say-busy{color:var(--text-3)}
+.tf-say code{display:block;margin-top:6px;font-family:var(--mono);font-size:12.5px;color:var(--text);background:var(--panel);border:1px solid var(--white-08);border-radius:8px;padding:8px 10px;word-break:break-all;user-select:all}
+.tf-story-where{max-width:760px;margin:0 auto}
+.tf-where{list-style:none;margin:0;padding:0;border-radius:12px;border:1px solid var(--white-08);overflow:hidden}
+.tf-where-row{display:grid;grid-template-columns:96px minmax(0,1fr) auto;gap:14px;align-items:center;padding:12px 14px;border-top:1px solid var(--white-06);background:var(--card)}
+.tf-where-row:first-child{border-top:0}
+.js .tf-where-row.tf-more{display:none}
+.tf-where-day{display:block;font-size:14px;font-weight:600}
+.tf-where-time{display:block;font-size:13px;color:var(--text-3)}
+.tf-where-ask{font-size:14.5px;overflow-wrap:anywhere}
+.tf-where-none{font-size:13px;color:var(--text-4)}
+.tf-where-foot{display:flex;justify-content:space-between;gap:12px;margin-top:8px}
+.tf-where-foot:empty{display:none}
+.tf-all{background:transparent;border:none;color:var(--coral-text);font:inherit;font-size:13.5px;font-weight:600;cursor:pointer;padding:4px 0}
+.tf-dev{margin-top:28px}
+.tf-dev-toggle{display:inline-block;cursor:pointer;list-style:none;color:var(--text-2);font-size:14px;font-weight:600;padding:4px 0}
+.tf-dev-toggle::-webkit-details-marker{display:none}
+.tf-dev-toggle:after{content:" ▾"}.tf-dev[open] .tf-dev-toggle:after{content:" ▴"}
+.tf-dev-body{display:flex;flex-direction:column;gap:16px;margin-top:12px}
+.tf-dev-lead{margin:0;max-width:640px;font-size:14px;line-height:1.5;color:var(--text-2)}
+.tf-dev .dt-row{align-items:start;padding:14px 20px}
+.tf-dev-label{display:block;font-family:var(--mono);font-size:12.5px;font-weight:600;letter-spacing:0.02em;color:var(--text);white-space:nowrap}
+.tf-dev-means{display:block;margin-top:4px;font-size:13px;line-height:1.4;color:var(--text-3)}
+.tf-dev-count{display:block;margin-bottom:8px;font-size:13px;font-weight:600;color:var(--text-2)}
+.tf-dev-commands{display:flex;flex-direction:column;gap:12px;border-radius:12px;background:var(--panel);border:1px solid var(--white-08);padding:14px 18px}
+.tf-dev-h{margin:0;font-size:12.5px;font-weight:600;color:var(--text-3)}
+.tf-dev-command{display:flex;flex-direction:column;gap:3px}
+.tf-dev-does{font-size:13px;color:var(--text-2)}
+.tf-dev-command code{font-family:var(--mono);font-size:13px;color:var(--text-soft);overflow-wrap:anywhere}
+@media (max-width:640px){.tf-window-head{padding:20px 18px 16px}.tf-window-body{padding:20px 18px}
+.tf-where-row{grid-template-columns:minmax(0,1fr) auto;grid-template-areas:"when see" "ask see";row-gap:4px}
+.tf-where-when{grid-area:when;display:flex;gap:8px;align-items:baseline}.tf-where-ask{grid-area:ask}.tf-where-row>:last-child{grid-area:see}}
+@media (max-width:760px){.tf-done-row{grid-template-columns:1fr}}
+.sw-body .tabs-inset .tabs-pill{white-space:nowrap;flex:none}
+@media (max-width:640px){.sw-body>.tabs>.tabs-bar{max-width:100%;overflow-x:auto;scrollbar-width:none}.sw-body .tabs-inset .tabs-pill{padding:7px 12px}}
+`;

package/dist/report/start/to-fix/to-fix-script.js

@@ -0,0 +1,94 @@
+/**
+ * What only To fix does (`.ai/plans/2026-09-23-to-fix-redesign.md`, step 3). The kit opens and closes the windows and
+ * switches the tabs, and the Fix it wizard writes a mark; this posts an undo, and reads the page again once the server
+ * has written either (R60), so the lists show what the record of marks holds and never what was clicked - after a mark,
+ * once the last window is closed, so "Next file" still opens the next one. A refusal is said in the server's words
+ * (R59). Opened as a file, nothing can be written, and the same button shows the command that would do it (T17).
+ */
+export const TO_FIX_SCRIPT = String.raw `
+(() => {
+  const root = document.querySelector('[data-to-fix]');
+  if (!root) return;
+  const served = location.protocol === 'http:' || location.protocol === 'https:';
+  const words = JSON.parse(root.dataset.fixWords || '{}');
+  const word = (key) => (words[document.documentElement.dataset.lang] || words.en || {})[key] || '';
+  const TABS = ['todo', 'done'];
+
+  // The tab a person was on survives the page being read again after a write.
+  const pills = [...root.querySelectorAll(':scope .tabs-bar [data-tab]')];
+  if (location.hash === '#done' && pills[1]) pills[1].click();
+  pills.forEach((pill, at) => pill.addEventListener('click', () => history.replaceState(null, '', '#' + TABS[at])));
+
+  const say = (where, text, command, busy) => {
+    const line = where && where.querySelector('[data-fix-say]');
+    if (!line) return;
+    line.textContent = text;
+    line.classList.toggle('tf-say-busy', busy === true);
+    if (command) {
+      const code = document.createElement('code');
+      code.textContent = command;
+      line.append(code);
+    }
+    line.hidden = false;
+  };
+
+  const quote = (text) => /^[\w@%+=:,./-]+$/.test(text) ? text : "'" + text.replace(/'/g, "'\\''") + "'";
+
+  const reload = () => {
+    const tab = TABS[pills.findIndex((pill) => pill.classList.contains('tabs-on'))] || TABS[0];
+    location.replace(location.pathname + '?at=' + Date.now() + '#' + tab);
+  };
+
+  // A mark the wizard wrote: the page is read again when no window is left open.
+  let marked = false;
+  root.addEventListener('wizard-marked', () => { marked = true; });
+  document.addEventListener('close', () => {
+    if (marked) setTimeout(() => { if (!document.querySelector('dialog[open]')) reload(); }, 0);
+  }, true);
+
+  const post = (url, body, where, button) => {
+    button.disabled = true;
+    say(where, word('saving'), '', true);
+    fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) })
+      // The server answers a refusal in JSON, and a request it does not take (a wrong origin, a lost token) in plain
+      // text: both are its answer, said as it gave it. Only a request that got no answer at all is "unreachable".
+      .then((response) => response.text().then((text) => {
+        let answer = {};
+        try { answer = JSON.parse(text); } catch { answer = { message: text.trim() }; }
+        return { ok: response.ok && answer.ok === true, message: answer.message || String(response.status) };
+      }), () => ({ ok: false, message: word('unreachable') }))
+      .then((answer) => {
+        if (answer.ok) { reload(); return; }
+        button.disabled = false;
+        say(where, word('refused') + ' ' + answer.message);
+      });
+  };
+
+  root.addEventListener('click', (event) => {
+    // "Fix it" in What happened: the wizard opens in its place, not over it.
+    const from = event.target.closest('[data-fix-from]');
+    if (from) {
+      const where = from.closest('dialog');
+      if (where && where.open) setTimeout(() => where.close(), 0);
+      return;
+    }
+
+    const unmark = event.target.closest('[data-fix-unmark]');
+    if (unmark) {
+      const where = unmark.closest('dialog');
+      const body = JSON.parse(unmark.dataset.fixUnmark);
+      if (!served) { say(where, word('asFile'), 'agentwhy check --unmark ' + quote(body.path)); return; }
+      post('api/unmark', body, where, unmark);
+      return;
+    }
+
+    const all = event.target.closest('[data-fix-all]');
+    if (all) {
+      // The list is the same in the wizard's fold, in What happened's Conversations tab and in the small window.
+      const section = all.closest('.tf-where-block');
+      if (section) section.querySelectorAll('.tf-more').forEach((row) => row.classList.remove('tf-more'));
+      all.hidden = true;
+    }
+  });
+})();
+`;

package/dist/report/start/to-fix/to-fix-view.js

@@ -0,0 +1,124 @@
+import { resultAllowed } from '../../check/marks.js';
+import { matchesGlob } from '../../../core/policy/glob.js';
+import { ruleKey } from '../../render/report-page/item-names.js';
+import { NOTHING_READ, toDoItem } from '../../render/report-page/to-do.js';
+import { localClock } from '../../render/ui/local-date.js';
+import { ruleNameOf } from '../../rule-names.js';
+const GROUP_OF = {
+    rotate: 'keys',
+    template: 'look',
+    // D1: an outcome nobody recorded is looked at, like a sample file, and closed as handled.
+    unknown: 'look',
+    route: 'seen',
+    result: 'seen',
+};
+/**
+ * T14: the buttons a file's window offers, in the order they are drawn, each the mark it writes. Only those
+ * `resultAllowed` lets a line take are offered: a file a key was read from is closed as rotated and nothing else.
+ */
+const RESULTS_OF = {
+    rotate: ['rotated'],
+    template: ['not-secret', 'rotated'],
+    unknown: ['handled'],
+    route: [],
+    result: [],
+};
+/**
+ * T14: the one mark besides the wizard's Done: a sample file's "No real keys here", an unrecorded outcome's "I checked
+ * it", a file with no key in it "Nothing private in it" - each only where its line may take it.
+ */
+const SKIP_OF = {
+    rotate: (item, allowed) => (item.kind === 'data' && allowed('not-private') ? 'not-private' : null),
+    template: (_item, allowed) => (allowed('not-secret') ? 'not-secret' : null),
+    // A file with no key in it is closed as handled by the wizard's Done already; its skip is the one left.
+    unknown: (item, allowed) => (item.kind === 'data' ? (allowed('not-private') ? 'not-private' : null) : allowed('handled') ? 'handled' : null),
+    route: () => null,
+    result: () => null,
+};
+export function toFixView(index) {
+    const clock = localClock(index.timeZone ?? 'UTC');
+    const today = clock(index.now).day.number;
+    const when = (at) => {
+        const { day, time } = clock(at);
+        const relative = day.number === today ? 'today' : day.number === today - 1 ? 'yesterday' : undefined;
+        return { at, day, time, ...(relative === undefined ? {} : { relative }) };
+    };
+    const patterns = index.settings?.protected ?? [];
+    const byName = new Map(index.entries.map((entry) => [entry.name, entry]));
+    const check = index.check;
+    const file = (row) => {
+        const name = ruleNameOf(row.path, patterns);
+        const conversations = row.sessions
+            .flatMap((session) => {
+            const entry = byName.get(session);
+            return entry === undefined ? [] : [{
+                    entry,
+                    when: when(entry.modifiedAt),
+                    ...(entry.report.kind === 'generated' ? { report: entry.report.file } : {}),
+                }];
+        })
+            .sort((a, b) => b.when.at - a.when.at);
+        // A key was read from it, so "No real keys" would contradict what the record holds: only rotated closes it,
+        // though the server would take not-secret for any sample file (`resultAllowed`).
+        const allowed = (result) => resultAllowed(row, result) && !(row.keyed === true && result === 'not-secret');
+        // The built-in rule's own pattern names the file for the wizard (F45): a rule's file holds keys.
+        const pattern = patterns.find((each) => ruleKey(each) !== undefined && matchesGlob(row.path, each));
+        const item = toDoItem(row.path, row.read ?? NOTHING_READ, {
+            template: row.label === 'template',
+            further: false,
+            readers: 1,
+            ...(pattern === undefined ? {} : { pattern: pattern }),
+        });
+        const told = conversations.flatMap((conversation) => {
+            const stories = conversation.entry.report.kind === 'generated' ? conversation.entry.report.stories : undefined;
+            const story = stories?.files.get(row.path);
+            return story === undefined || stories === undefined ? [] : [{ story, sessionId: stories.sessionId, conversation }];
+        })[0];
+        return {
+            path: row.path,
+            label: row.label,
+            ...(told === undefined ? {} : { story: told }),
+            ...(name === undefined ? {} : { name }),
+            ...(row.reopened === undefined ? {} : { reopened: when(row.reopened.at) }),
+            results: RESULTS_OF[row.label].filter(allowed),
+            item,
+            skip: SKIP_OF[row.label](item, allowed),
+            conversations,
+            count: row.sessions.length,
+        };
+    };
+    const rows = (check?.rows ?? []).map((row) => ({ row, fix: file(row) }));
+    const inGroup = (group) => rows.filter(({ row }) => GROUP_OF[row.label] === group).map(({ fix }) => fix).sort(byUrgency);
+    const keys = inGroup('keys');
+    const look = inGroup('look');
+    const done = (check?.history ?? [])
+        .filter((line) => line.status === 'standing' && !line.reopened)
+        .map((line) => {
+        const name = ruleNameOf(line.path, patterns);
+        return {
+            path: line.path,
+            label: line.label,
+            ...(name === undefined ? {} : { name }),
+            result: line.result,
+            when: when(line.at),
+            ...(line.note === undefined ? {} : { note: line.note }),
+        };
+    })
+        .sort((a, b) => b.when.at - a.when.at);
+    return {
+        keys,
+        look,
+        seen: inGroup('seen'),
+        done,
+        refusedAttempts: check?.refusedAttempts ?? 0,
+        state: keys.length > 0 ? 'keys' : look.length > 0 ? 'look' : 'none',
+        total: keys.length + look.length,
+        marksUnreadable: check?.marksUnreadable === true,
+    };
+}
+/** T8: the files more conversations reached first, as the design orders them, then by path so the order is stable. */
+function byUrgency(a, b) {
+    if (a.count !== b.count)
+        return b.count - a.count;
+    return a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
+}

package/dist/report/watch/agent-alert.js

@@ -0,0 +1,72 @@
+export const ALERT_THRESHOLDS = ['value', 'reached', 'refused'];
+/**
+ * What is said when nobody has said otherwise: only a value written from a protected file. The other two are worth
+ * having and worth asking for; on every session they are a line about work that went as it should.
+ */
+export const DEFAULT_THRESHOLD = 'value';
+/**
+ * What can be said about one agent of a report, read from the report model and nothing else (R6): its return, which
+ * already looks at every agent below it, and the graph for an agent no delegation recorded, which has no return.
+ */
+export function alertOf(report, agentIndex) {
+    // The session's own agent is asked about too, on `Stop` (`the-agent-nobody-watches.md` R2): it is the one agent
+    // with no `SubagentStop`, and the graph keeps it apart from the agents it delegated to.
+    const everyone = [report.graph.main, ...report.graph.agents];
+    const node = everyone.find((agent) => agent.index === agentIndex);
+    if (node === undefined)
+        return undefined;
+    // Handed the root, this subtree is every agent of the session, which is what a session-wide question needs (R5).
+    const subtree = subtreeOf(everyone, node);
+    const own = report.returns.filter((statement) => statement.agentIndex === agentIndex);
+    const wroteOrReturnedValue = own.some((statement) => statement.strength === 'value' || statement.writtenFrom.length > 0);
+    const reachedFromReturn = own.reduce((most, statement) => Math.max(most, statement.filesReached), 0);
+    const reachedBelow = subtree.filter((agent) => agent !== node).some((agent) => agent.filesReached > 0);
+    /*
+     * The session's own agent answers a person, not an agent that delegated to it, so no return statement says what it
+     * carried, and `wroteValue` and `wroteOnward` - written for what came back from a delegated agent - stay unset on
+     * it. What there is to read for it is the traced use itself: measured on a real session where the main agent
+     * searched, printed a value from a protected file and the model recorded one `use`, while the flags read false and
+     * the level came out `reached`. A value in the conversation is not a path in a result, and it is not said as one.
+     */
+    const usedItself = report.uses.some((statement) => statement.agentIndex === node.index);
+    const wroteItself = node.wroteValue === true || node.wroteOnward === true || usedItself;
+    const reached = reachedFromReturn > 0 || node.filesReached > 0 || reachedBelow;
+    const refusedAttempts = subtree.reduce((sum, agent) => sum + agent.refusedAttempts, 0);
+    const filesReached = own.length > 0 ? reachedFromReturn : reachedBelow ? undefined : node.filesReached;
+    const level = wroteOrReturnedValue || wroteItself ? 'value' : reached ? 'reached' : refusedAttempts > 0 ? 'refused' : 'nothing';
+    return {
+        level,
+        ...(node === report.graph.main ? { own: true } : {}),
+        ...(node.type === undefined ? {} : { type: node.type }),
+        ...(filesReached === undefined ? {} : { filesReached }),
+        refusedAttempts,
+    };
+}
+/** Whether a level is strong enough to be said, under the threshold asked for. */
+export function alerts(level, threshold) {
+    switch (level) {
+        case 'value':
+            return true;
+        case 'reached':
+            return threshold !== 'value';
+        case 'refused':
+            return threshold === 'refused';
+        case 'nothing':
+            return false;
+    }
+}
+/** The agent and every agent below it, by the parents the graph established - never by depth or order. */
+function subtreeOf(agents, root) {
+    const below = new Set([root.index]);
+    let grew = true;
+    while (grew) {
+        grew = false;
+        for (const agent of agents) {
+            if (agent.parentIndex !== undefined && below.has(agent.parentIndex) && !below.has(agent.index)) {
+                below.add(agent.index);
+                grew = true;
+            }
+        }
+    }
+    return agents.filter((agent) => below.has(agent.index));
+}

package/dist/report/watch/notice-choices.js

@@ -0,0 +1,35 @@
+/**
+ * The choices a notice can be given, in a module of their own so that both the code that says a notice and the code
+ * that remembers what a person chose can name them without depending on each other.
+ */
+export const NOTICE_CHANNELS = ['chat', 'terminal', 'os'];
+/**
+ * What `--notify` uses when nobody says otherwise: the line in the conversation, and no pop-up. The other two
+ * arrive the moment an agent finishes rather than at the end of the turn, which is worth having and worth asking
+ * for; on a first run they are three notices for one finding.
+ */
+export const DEFAULT_CHANNELS = ['chat'];
+export const CLEAN_MODES = ['off', 'once', 'every-turn'];
+/**
+ * What `--clean` does when nobody says otherwise. Silence is ambiguous - a hook that failed quietly reads exactly
+ * like an agent that did nothing - and one line per session is what it costs to tell those apart.
+ */
+export const DEFAULT_CLEAN = 'once';
+export const SAID_AS = ['line', 'agent'];
+/**
+ * What a `value` does when nobody has said otherwise. B9a measured that the agent is continued and answers; B9d
+ * measured eleven sessions of eleven relaying these words, never going back to the file and never repeating a
+ * value. A grey line under a reply is read as a debug note; this is the finding that only rotating a key undoes.
+ */
+export const DEFAULT_SAID_AS = 'agent';
+export const NOTICE_LANGS = ['en', 'pl', 'de'];
+/** What a line is written in when nobody chose and the system says nothing this tool knows. */
+export const DEFAULT_LANG = 'en';
+/**
+ * The language a system locale names - `pl_PL.UTF-8`, `de-DE` - when it is one a line is written in. `C` and `POSIX`
+ * name none, and neither does a locale this tool has no words for.
+ */
+export function langOfLocale(locale) {
+    const code = locale?.slice(0, 2).toLowerCase();
+    return NOTICE_LANGS.find((lang) => lang === code);
+}

package/dist/report/watch/notice-settings.js

@@ -0,0 +1,65 @@
+import { dirname } from 'node:path';
+import { longestMatch, NO_PREFERENCES, preferencesFor, readPreferences, withProjectChoices, writtenPreferences, } from './preferences.js';
+/**
+ * Reading and changing what a person wants to be told (`specs/2026-09-21-the-agent-tells-you.md` R22-R26). The hook
+ * only ever reads this file; this is the one place that writes it, and the page's Settings view writes through here
+ * rather than through a second copy of the rules.
+ */
+export class NoticeSettings {
+    #dependencies;
+    constructor(dependencies) {
+        this.#dependencies = dependencies;
+    }
+    async view() {
+        const { path, workingDirectory } = this.#dependencies;
+        const read = readPreferences(await this.#text());
+        const preferences = read.kind === 'read' ? read.preferences : NO_PREFERENCES;
+        return {
+            path,
+            project: workingDirectory,
+            defaults: preferences.defaults,
+            // The same project `effective` resolves to (R24): the longest ancestor match, not an exact key alone - a
+            // directory inside a project a choice was made for is still governed by it, and must be attributed to it too.
+            forProject: longestMatch(preferences.projects, workingDirectory) ?? {},
+            effective: preferencesFor(preferences, workingDirectory),
+            unusable: read.kind === 'unusable',
+        };
+    }
+    /**
+     * One change, written whole. A file this version cannot read is not edited around: it is replaced by what is being
+     * asked for now, and the answer says so, because merging into a shape nobody recognised is how a choice quietly
+     * becomes something else.
+     */
+    async change(change) {
+        const { files: _files, writer, path, workingDirectory } = this.#dependencies;
+        const read = readPreferences(await this.#text());
+        const before = read.kind === 'read' ? read.preferences : NO_PREFERENCES;
+        const after = changed(before, change, workingDirectory);
+        try {
+            await writer.ensureDirectory(dirname(path));
+            await writer.writeText(path, writtenPreferences(after));
+        }
+        catch {
+            return { written: false, said: `Nothing was written: ${path} could not be written to.` };
+        }
+        const where = change.scope === 'project' ? workingDirectory : 'every project';
+        const what = change.reset === true ? 'Answers taken out' : 'Answers written';
+        const replaced = read.kind === 'unusable' ? ' The file could not be read, so it was replaced.' : '';
+        return { written: true, said: `${what} for ${where}, in ${path}.${replaced}` };
+    }
+    async #text() {
+        try {
+            return await this.#dependencies.files.readText(this.#dependencies.path);
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+function changed(before, change, workingDirectory) {
+    if (change.scope === 'everywhere') {
+        return { defaults: change.reset === true ? {} : { ...before.defaults, ...change.choices }, projects: before.projects };
+    }
+    const project = before.projects[workingDirectory] ?? {};
+    return withProjectChoices(before, workingDirectory, change.reset === true ? {} : { ...project, ...change.choices });
+}