@agentwhy/cli 0.0.0-dev

package/dist/report/start/settings/settings-windows.js

@@ -0,0 +1,334 @@
+import { escapeHtml as e } from '../../render/html-report-components.js';
+import { inLanguages } from '../../render/report-copy.js';
+import { addFilePopup } from '../../render/ui/add-file-popup.js';
+import { confirmDialog } from '../../render/ui/confirm-dialog.js';
+/** The window a hook's switch opens: the one that turns it on where it is off, and off where it is on. */
+export function hookWindowId(hook, on) {
+    return 'set-' + hook + '-' + (on ? 'on' : 'off');
+}
+export const WATCH_WINDOW = 'set-watch-too';
+/** K8, K9: every private file that is not blocked whole, blocked in one confirmed write. */
+export const FINISH_WINDOW = 'set-finish';
+export const ADD_WINDOW = 'set-add';
+/** `codex-blocks-too` CK5: the files blocked here, kept from Codex's shell commands too. */
+export const CODEX_WINDOW = 'set-codex';
+export const ADD_CONFIRM_WINDOW = 'set-add-confirm';
+/** The window a row not watched yet opens (F34a): that one group, confirmed like every other write. */
+export function rowWatchWindowId(at) {
+    return 'set-watch-row-' + at;
+}
+export function removeWindowId(at) {
+    return 'set-remove-' + at;
+}
+/** F57: the confirmation of one row's switch, and of taking a told row off its list. */
+export function modeWindowId(at) {
+    return 'set-mode-' + at;
+}
+export function untellWindowId(at) {
+    return 'set-untell-' + at;
+}
+/** General's confirmation of making everything agentwhy saved one file's (F56). */
+export function scopeWindowId(file) {
+    return 'set-scope-' + file;
+}
+/** General's **Uninstall** (F59). */
+export const UNINSTALL_WINDOW = 'set-uninstall';
+export function settingsWindows(view) {
+    if (!view.canWrite)
+        return '';
+    return hookWindow(view, 'watch') + finishWindow(view) + codexWindow(view) + scopeWindow(view, 'local') + scopeWindow(view, 'shared') + uninstallWindow(view) +
+        (view.unread.length > 0 || view.rows.some((row) => !row.watched) ? watchWindow(view) : '') +
+        view.rows.map((row, at) => (row.watched || row.name === undefined ? '' : rowWatchWindow(view, row.name, row.patterns, at))).join('') +
+        view.rows.map((row, at) => (row.remove === undefined ? '' : removeWindow(at, row.remove.rule, row.remove.file))).join('') +
+        view.rows.map((row, at) => (row.switchTo === undefined ? '' : modeWindow(view, row, at))).join('') +
+        view.rows.map((row, at) => (row.untell === undefined ? '' : untellWindow(view, row, at))).join('') +
+        (view.canAdd ? addWindow() + addConfirmWindow(view) : '');
+}
+/**
+ * F40: turning alerts on or off, confirmed; turning off is the coral button. It is written where General says (F56) -
+ * the one file everything is in, else where an add goes - and asks nobody again. `refuse` has no window of its own: it
+ * is half of every block (`block-means-blocked` K1), and Finish blocking is where a missing one is put back.
+ */
+function hookWindow(view, hook) {
+    const state = view.alerts;
+    const on = !state.on;
+    const words = 'set.confirm.alerts.' + (on ? 'on' : 'off');
+    const id = hookWindowId(hook, on);
+    const where = on ? view.writeTo : state.who ?? 'local';
+    // `init --watch` alone takes a running `refuse` out of the file it writes (R4b), so the command names it too
+    // wherever it runs from that file; the page's own write says the same with `keep`.
+    const otherIn = view.stop.who === where;
+    const command = on
+        ? 'agentwhy init --' + hook + (otherIn ? ' --refuse' : '') + shared(where)
+        : 'agentwhy init --remove --' + hook + shared(where);
+    return confirmDialog({
+        id,
+        glyph: '',
+        title: inLanguages((t) => t(words)),
+        subject: '',
+        sentence: inLanguages((t) => t(words + '.text')),
+        option: '',
+        note: say(),
+        cancel: inLanguages((t) => t('app.cancel')),
+        confirm: inLanguages((t) => t(on ? 'set.confirm.turnOn' : 'set.confirm.turnOff')),
+        tone: on ? 'mint' : 'primary',
+        confirmAttributes: write({ change: 'hooks', hooks: [hook], on, where }) + commandAttribute(where, command),
+    });
+}
+/**
+ * F56: everything agentwhy saved, into one file - its rules moved one by one, then its hooks. Offered only where there
+ * is something to move; the command for a page opened as a file is the same runs, in the same order.
+ */
+function scopeWindow(view, file) {
+    const move = view.moves[file];
+    if (move.patterns.length === 0 && move.hooks.length === 0)
+        return '';
+    const from = file === 'local' ? 'shared' : 'local';
+    const commands = [
+        ...move.patterns.flatMap((pattern) => [
+            'agentwhy init --remove --unprotect ' + quoted(pattern) + shared(from),
+            'agentwhy init --protect ' + quoted(pattern) + shared(file),
+        ]),
+        ...(move.hooks.length === 0 ? [] : ['agentwhy init ' + hooksNow(view, file, move.hooks).map((hook) => '--' + hook).join(' ') + shared(file)]),
+    ];
+    return confirmDialog({
+        id: scopeWindowId(file),
+        glyph: '',
+        title: inLanguages((t) => t('set.confirm.scope.' + file)),
+        subject: '',
+        sentence: inLanguages((t) => t('set.confirm.scope.' + file + '.text')),
+        option: '',
+        note: say(),
+        cancel: inLanguages((t) => t('app.cancel')),
+        confirm: inLanguages((t) => t('set.confirm.scope.go')),
+        tone: 'mint',
+        confirmAttributes: write({ change: 'scope', patterns: move.patterns, hooks: move.hooks, where: file }) + commandAttribute(file, commands.join(' && ')),
+    });
+}
+/**
+ * F59: both hooks and every whole rule agentwhy wrote, out of each file that holds any - the coral button, since it takes
+ * all protection away. It says what stays, and, where the shared file is one of them, that everyone gets the change.
+ */
+function uninstallWindow(view) {
+    const files = ['local', 'shared'].filter((file) => view.uninstall[file] !== undefined);
+    if (files.length === 0)
+        return '';
+    const command = files.map((file) => 'agentwhy init --remove --watch --refuse' +
+        (view.uninstall[file] ?? []).map((rule) => ' --unprotect ' + quoted(rule)).join('') + shared(file)).join(' && ');
+    return confirmDialog({
+        id: UNINSTALL_WINDOW,
+        glyph: '',
+        title: inLanguages((t) => t('set.confirm.uninstall')),
+        subject: '',
+        sentence: inLanguages((t) => t('set.confirm.uninstall.text') + (files.includes('shared') ? ' ' + t('set.confirm.everyone') : '')),
+        option: '',
+        note: say(),
+        cancel: inLanguages((t) => t('app.cancel')),
+        confirm: inLanguages((t) => t('set.confirm.uninstall.go')),
+        tone: 'primary',
+        confirmAttributes: write({ change: 'uninstall', rules: view.uninstall }) + commandAttribute('local', command),
+    });
+}
+/** The hooks a file runs once the moved ones are in it: `init` with hook flags takes out any it is not given (R4b). */
+function hooksNow(view, file, moved) {
+    const there = ['watch', 'refuse'].filter((hook) => (hook === 'watch' ? view.alerts.who : view.stop.who) === file);
+    return [...new Set([...there, ...moved])];
+}
+/**
+ * K9: what is missing of every block, in one write - the rules no file holds, with the built-in list and `refuse`, as an
+ * add writes them; or, where every rule is there, `refuse` alone, where it is written and asks nobody (F56). The window
+ * names the files as their rows do, and closes with the guidelines' honesty line, as every block does.
+ */
+function finishWindow(view) {
+    const { rows, patterns, refuse } = view.unfinished;
+    if (patterns.length === 0 && !refuse)
+        return '';
+    const open = view.rows.filter((row) => row.kept !== undefined);
+    const alertsIn = view.alerts.who === view.writeTo;
+    const confirmAttributes = patterns.length > 0
+        ? write({ change: 'adopt', patterns, where: view.addTo }) + commandAttribute(view.addTo, protectCommand(view, patterns, view.addTo))
+        : write({ change: 'hooks', hooks: ['refuse'], on: true, where: view.writeTo }) +
+            commandAttribute(view.writeTo, 'agentwhy init --refuse' + (alertsIn ? ' --watch' : '') + shared(view.writeTo));
+    return confirmDialog({
+        id: FINISH_WINDOW,
+        glyph: '',
+        title: inLanguages((t) => t('set.finish.title')),
+        subject: '',
+        sentence: inLanguages((t) => t('set.finish.text', { n: rows, names: open.map((row) => rowName(row, t)).join(', ') }) +
+            // The built-in list it writes is what these rows are, so the add's "written into your project with it" is not said.
+            ((patterns.length > 0 ? view.addTo : view.writeTo) === 'shared' ? ' ' + t('set.confirm.everyone') : '') +
+            '<span class="set-soft set-honest">' + t('set.finish.honest') + '</span>'),
+        option: '',
+        note: say(),
+        cancel: inLanguages((t) => t('app.cancel')),
+        confirm: inLanguages((t) => t('set.finish.yes', { n: rows })),
+        tone: 'mint',
+        confirmAttributes,
+    });
+}
+/**
+ * CK5, CK7: Codex's hook, written to match the block Claude Code runs - the page's confirmation is the consent, as for
+ * every block - and the honesty line under it. Opened as a file, it hands over `agentwhy init --codex`.
+ */
+function codexWindow(view) {
+    if (view.codex !== 'off' || !view.stop.on)
+        return '';
+    return confirmDialog({
+        id: CODEX_WINDOW,
+        glyph: '',
+        title: inLanguages((t) => t('set.codex.title')),
+        subject: '',
+        sentence: inLanguages((t) => t('set.codex.text') + '<span class="set-soft set-honest">' + t('set.finish.honest') + '</span>'),
+        option: '',
+        note: say(),
+        cancel: inLanguages((t) => t('app.cancel')),
+        confirm: inLanguages((t) => t('set.codex.yes')),
+        tone: 'mint',
+        confirmAttributes: write({ change: 'codex' }) + commandAttribute(view.writeTo, 'agentwhy init --codex'),
+    });
+}
+/** F34 and O7: the project's own rules, copied into the file the hooks read - with the built-in list where it is missing. */
+function watchWindow(view) {
+    const patterns = [...new Set([...view.withBuiltIn, ...view.unread.map((rule) => rule.rule)])];
+    return confirmDialog({
+        id: WATCH_WINDOW,
+        glyph: '',
+        title: inLanguages((t) => t('set.confirm.watch')),
+        subject: '',
+        sentence: inLanguages((t) => t('set.confirm.watch.text') + extra(view, t)),
+        option: '',
+        note: say(),
+        cancel: inLanguages((t) => t('app.cancel')),
+        confirm: inLanguages((t) => t('set.confirm.watch.go')),
+        confirmAttributes: write({ change: 'adopt', patterns, where: view.addTo }) + commandAttribute(view.addTo, protectCommand(view, patterns, view.addTo)),
+    });
+}
+/** F34a: one built-in group written into the file the hooks read - the same change as Watch them too, for that group. */
+function rowWatchWindow(view, name, patterns, at) {
+    return confirmDialog({
+        id: rowWatchWindowId(at),
+        glyph: '',
+        title: inLanguages((t) => t('set.confirm.row')),
+        subject: '',
+        sentence: inLanguages((t) => t('set.confirm.row.text', { name: '<strong>' + t('set.rule.' + name) + '</strong>' })),
+        option: '',
+        note: say(),
+        cancel: inLanguages((t) => t('app.cancel')),
+        confirm: inLanguages((t) => t('set.confirm.watch.go')),
+        confirmAttributes: write({ change: 'adopt', patterns, where: view.addTo }) + commandAttribute(view.addTo, protectCommand(view, patterns, view.addTo)),
+    });
+}
+/**
+ * F57: one row to the other mode. Going to Tell me is the risky way, so it is the coral button and says the cost - for a
+ * built-in group, in the words of the decision of 2026-09-24: what is inside goes to the AI company, and only changing
+ * the keys undoes it. Where alerts are off, it says the report is then the only place it is seen. Going to Block is
+ * the mint "Yes, block it". A page opened as a file cannot write a told list, so its command is `agentwhy start`.
+ */
+function modeWindow(view, row, at) {
+    const change = row.switchTo;
+    const tell = change.to === 'tell';
+    const words = tell ? (row.name === undefined ? 'set.confirm.tell' : 'set.confirm.tell.secret') : 'set.confirm.block';
+    return confirmDialog({
+        id: modeWindowId(at),
+        glyph: '',
+        title: inLanguages((t) => t(words)),
+        subject: '',
+        sentence: inLanguages((t) => t(words + '.text', { name: rowName(row, t) }) + (tell && !view.alerts.on ? ' ' + t('set.confirm.tell.alertsOff') : '')),
+        option: '',
+        note: say(),
+        cancel: inLanguages((t) => t('app.cancel')),
+        confirm: inLanguages((t) => t(tell ? 'set.confirm.tell.go' : 'set.confirm.block.go')),
+        tone: tell ? 'primary' : 'mint',
+        confirmAttributes: write({ change: 'mode', to: change.to, patterns: change.patterns, rules: change.rules, where: view.writeTo }) + commandAttribute(view.writeTo, 'agentwhy start'),
+    });
+}
+function untellWindow(view, row, at) {
+    return confirmDialog({
+        id: untellWindowId(at),
+        glyph: '',
+        title: inLanguages((t) => t('set.confirm.untell')),
+        subject: '',
+        sentence: inLanguages((t) => t('set.confirm.untell.text', { name: rowName(row, t) })),
+        option: '',
+        note: say(),
+        cancel: inLanguages((t) => t('app.cancel')),
+        confirm: inLanguages((t) => t('set.confirm.remove.go')),
+        tone: 'primary',
+        confirmAttributes: write({ change: 'mode', to: 'none', patterns: row.untell ?? [], rules: [], where: view.writeTo }) + commandAttribute(view.writeTo, 'agentwhy start'),
+    });
+}
+/** A row as a sentence names it: a built-in group by its words, anything else by its pattern. */
+function rowName(row, t) {
+    return row.name === undefined ? '<code class="set-code">' + e(row.patterns[0] ?? '') + '</code>' : '<strong>' + t('set.rule.' + row.name) + '</strong>';
+}
+function removeWindow(at, rule, file) {
+    return confirmDialog({
+        id: removeWindowId(at),
+        glyph: '',
+        title: inLanguages((t) => t('set.confirm.remove')),
+        subject: '',
+        sentence: inLanguages((t) => t('set.confirm.remove.text', { name: '<code class="set-code">' + e(rule) + '</code>' })),
+        option: '',
+        note: say(),
+        cancel: inLanguages((t) => t('app.cancel')),
+        confirm: inLanguages((t) => t('set.confirm.remove.go')),
+        tone: 'primary',
+        confirmAttributes: write({ change: 'unprotect', pattern: rule, where: file }),
+    });
+}
+/**
+ * F35, F36: the kit's "Add a private file" (`add-file-popup.ts`), which the onboarding opens too. It hands the page a
+ * name turned into a pattern, and Settings' script opens the confirmation below with it.
+ */
+function addWindow() {
+    return addFilePopup(ADD_WINDOW);
+}
+/** The confirmation of an add: the pattern exactly as it will be written (F35), and what it means in words (F36). */
+function addConfirmWindow(view) {
+    const name = '<code class="set-code" data-set-name></code>';
+    const kinds = ['file', 'folder', 'pattern'].map((kind) => '<span class="set-kind" data-set-kind="' + kind + '"' + (kind === 'file' ? '' : ' hidden') + '>' +
+        inLanguages((t) => t('set.confirm.add.' + kind, { name })) + '</span>').join('');
+    return confirmDialog({
+        id: ADD_CONFIRM_WINDOW,
+        glyph: '',
+        title: inLanguages((t) => t('set.confirm.add')),
+        subject: '<span class="chip set-pattern" data-set-pattern></span>',
+        sentence: kinds + inLanguages((t) => ' ' + t('set.confirm.add.also') + extra(view, t)),
+        option: '',
+        note: say(),
+        cancel: inLanguages((t) => t('app.cancel')),
+        confirm: inLanguages((t) => t('set.confirm.add.go')),
+        // What the script needs to post the add, and to say it as a command where the page is a file: `--watch` rides
+        // along where alerts run from that file, since `init` with a hook flag takes out any it is not given (R4b).
+        confirmAttributes: ' data-set-add="' + e(JSON.stringify({ builtIn: view.withBuiltIn, where: view.addTo, watch: view.alerts.who === view.addTo })) + '"',
+    });
+}
+/** What else a write from Private files does: the built-in list goes with it (S4.3), and a shared file reaches everyone. */
+function extra(view, t) {
+    return (view.withBuiltIn.length === 0 ? '' : ' ' + t('set.confirm.builtIn')) + (view.addTo === 'shared' ? ' ' + t('set.confirm.everyone') : '');
+}
+/**
+ * Protecting from a page opened as a file: the rules, and `refuse` with them (F38, amended 2026-09-24), and `watch`
+ * where it runs from the same file - `init` with a hook flag takes out any it is not given (R4b).
+ */
+function protectCommand(view, patterns, where) {
+    return 'agentwhy init' + patterns.map((pattern) => ' --protect ' + quoted(pattern)).join('') + ' --refuse' +
+        (view.alerts.who === where ? ' --watch' : '') + shared(where);
+}
+function shared(where) {
+    return where === 'shared' ? ' --shared' : '';
+}
+/** A shell word, quoted where it needs to be: the same rule the page's script uses for a typed name. */
+function quoted(text) {
+    return /^[\w@%+=:,./*-]+$/.test(text) ? text : "'" + text.replace(/'/g, "'\\''") + "'";
+}
+function commandAttribute(where, command) {
+    return ' data-set-command-' + where + '="' + e(command) + '"';
+}
+/** The line a window's script fills: saving, the reason a change was refused (R59), or the command to run (R61). */
+function say() {
+    return '<p class="set-say" data-set-say hidden></p>';
+}
+function write(body) {
+    return ' data-set-write="' + e(JSON.stringify(body)) + '"';
+}

package/dist/report/start/settings-files.js

@@ -0,0 +1,43 @@
+import { fileRulesIn } from '../../adapter/claude-code/settings/deny-entries.js';
+import { missingHookEntries } from '../../adapter/claude-code/settings/hook-entries.js';
+/**
+ * A settings file, read the way `init` reads it. Absent is an answer - a project nobody set up has none - and a file
+ * that is not a JSON object is `unreadable`, so nothing is drawn from a guess about what it holds.
+ */
+export async function readSettingsFile(files, path) {
+    let text;
+    try {
+        text = await files.readText(path);
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const settings = JSON.parse(text);
+        if (settings === null || typeof settings !== 'object' || Array.isArray(settings))
+            return 'unreadable';
+        return settings;
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+/**
+ * Whether a file runs a hook whole. `watch` is not installed where only one of its two events is (`hookEntries`'s own
+ * comment): a file left running `watch` on `SubagentStop` alone never says anything in the conversation and never checks
+ * the session's own agent, so a hook this incomplete reads as off - the `missingHookEntries` a fresh `init` uses to find
+ * the gap.
+ */
+export function hookComplete(settings, hook) {
+    return missingHookEntries(settings, [hook], '', undefined).length === 0;
+}
+/**
+ * Whether agentwhy is set up in a project, from its settings files (`.ai/specs/2026-09-27-which-project.md` V10, and the
+ * onboarding's W23 as amended the same day): one of its hooks runs there whole, or the files hold rules that block a file
+ * - a rule a person wrote by hand included. Decided by the maintainer on 2026-09-28: a project that blocks files is set
+ * up, and is not offered the setup again. A file that could not be read says nothing.
+ */
+export function setUpBy(files) {
+    return files.some((settings) => settings !== undefined && settings !== 'unreadable' &&
+        (hookComplete(settings, 'watch') || hookComplete(settings, 'refuse') || fileRulesIn(settings).length > 0));
+}

package/dist/report/start/to-fix/done-list.js

@@ -0,0 +1,45 @@
+import { escapeHtml as e } from '../../render/html-report-components.js';
+import { inLanguages } from '../../render/report-copy.js';
+import { textButton } from '../../render/ui/button.js';
+import { confirmDialog } from '../../render/ui/confirm-dialog.js';
+import { dayName } from '../../render/ui/local-date.js';
+import { opener } from '../../render/ui/popup.js';
+import { fileTitle } from './to-fix-list.js';
+export function undoWindowId(at) {
+    return 'fix-undo-' + at;
+}
+/** "today", "yesterday", or the day's date, in the page's zone (O2); `standing` starts a line: "Today". */
+export function dayWord(when, t, lang, standing = false) {
+    return when.relative === undefined ? dayName(when.day, lang) : t((standing ? 'fix.day.' : 'fix.') + when.relative);
+}
+/**
+ * The Done tab (T9, T10): every standing mark, newest first, with what the person wrote. A shared page lists them
+ * without the notes and without Undo (T19, R37).
+ */
+export function doneList(done, writable) {
+    if (done.length === 0)
+        return '<p class="tf-empty">' + inLanguages((t) => t('fix.done.none')) + '</p>';
+    return '<p class="tf-done-lead">' + inLanguages((t) => t('fix.done.lead')) + '</p>' +
+        '<ul class="tf-done">' + done.map((file, at) => '<li class="tf-done-row"><span class="tf-done-text"><span class="tf-done-title">' + inLanguages((t) => fileTitle(file, t)) + '</span>' +
+        '<span class="tf-done-sub"><span class="chip">' + e(file.path) + '</span>' +
+        (file.note === undefined ? '' : '<span class="tf-note">“' + e(file.note) + '”</span>') + '</span></span>' +
+        '<span class="tf-fixed">' + inLanguages((t, lang) => t('fix.done.fixed', { when: dayWord(file.when, t, lang) })) + '</span>' +
+        (writable ? textButton(inLanguages((t) => t('fix.done.undo')), opener(undoWindowId(at)), 'tf-undo') : '') +
+        '</li>').join('') + '</ul>';
+}
+/** T10: Undo puts back work the person said was done, so it asks first (D6). */
+export function undoWindows(done) {
+    return done.map((file, at) => confirmDialog({
+        id: undoWindowId(at),
+        glyph: '',
+        title: inLanguages((t) => t('fix.undo.title')),
+        subject: '<span class="chip">' + e(file.path) + '</span>',
+        sentence: inLanguages((t) => t('fix.undo.text')),
+        option: '',
+        note: '<p class="tf-say" data-fix-say hidden></p>',
+        cancel: inLanguages((t) => t('app.cancel')),
+        confirm: inLanguages((t) => t('fix.undo.go')),
+        tone: 'primary',
+        confirmAttributes: ' data-fix-unmark="' + e(JSON.stringify({ path: file.path })) + '"',
+    })).join('');
+}

package/dist/report/start/to-fix/file-window.js

@@ -0,0 +1,110 @@
+import { escapeHtml as e } from '../../render/html-report-components.js';
+import { inLanguages, labelAttributes } from '../../render/report-copy.js';
+import { closeButton, pill } from '../../render/ui/button.js';
+import { callout } from '../../render/ui/callout.js';
+import { fixWizard } from '../../render/report-page/fix-wizard.js';
+import { storyWindowOf } from '../../render/report-page/story-window.js';
+import { fixId, storyId } from '../../render/report-page/to-do-view.js';
+import { CLOSES, opener, popup, popupFoot } from '../../render/ui/popup.js';
+import { dayWord } from './done-list.js';
+import { fileTitle } from './to-fix-list.js';
+/** T15: the conversations shown before "Show all". */
+const FIRST = 6;
+/** The window a card's "What happened" opens (T11a): the report page's own id for it. */
+export function happenedId(at) {
+    return storyId(at);
+}
+/**
+ * A file's Fix it (T11-T15): the report page's own wizard, one step at a time, for the file as every conversation read
+ * it - with where it was read folded under "Now fixing", and a note in the last step, sent with the mark.
+ */
+export function fixWindow(files, at, page) {
+    const file = files[at];
+    return fixWizard(files.map((each) => each.item), at, {
+        done: new Set(),
+        shared: !page.writable,
+        protectKeys: new Map(),
+        protectedPaths: new Set(),
+        ...(page.told === undefined ? {} : { toldPaths: page.told }),
+        protectAt: page.settings + '#files',
+    }, {
+        ...(file.reopened === undefined ? {} : { notice: backAgain(file) }),
+        where: {
+            summary: inLanguages((t) => t('fix.window.where') + ' · ' + t('fix.in', { n: file.count })),
+            body: whereList(file),
+        },
+        note: page.writable,
+        skip: file.skip,
+        since: page.since,
+    });
+}
+/**
+ * "What happened" (T11a): the report page's own window - Story, Diagram, Record - told from the newest conversation that
+ * read the file, which it names, with every conversation in a fourth tab. A file no report could tell falls back to what
+ * the index knows: what the AI did, where, and what to do.
+ */
+export function happenedWindow(file, kind, at, page) {
+    if (file.story !== undefined) {
+        const { story, sessionId, conversation } = file.story;
+        const title = conversation.entry.title === undefined ? undefined : '“' + e(conversation.entry.title) + '”';
+        return storyWindowOf(story, file.item, at, sessionId, false, page.clock, {
+            context: inLanguages((t, lang) => t('fix.story.from', {
+                title: title ?? t('fix.window.untitled'),
+                day: dayWord(conversation.when, t, lang, true),
+                time: conversation.when.time,
+            }) + (file.count > 1 ? ' ' + t('fix.story.more', { n: file.count - 1 }) : '')),
+            tabs: [{ label: inLanguages((t) => t('fix.story.tab')) + ' <span class="tf-tab-count">' + file.count + '</span>', panel: '<div class="tf-story-where">' + whereList(file) + '</div>' }],
+        });
+    }
+    const id = happenedId(at);
+    const did = file.label === 'unknown' ? 'unknown' : kind;
+    const head = '<div class="tf-window-head"><div class="tf-window-top">' +
+        '<span class="tf-window-group tf-window-' + kind + '">' + inLanguages((t) => t('fix.' + kind)) + '</span>' +
+        closeButton(labelAttributes((t) => t('app.close')) + CLOSES) + '</div>' +
+        '<h2 class="tf-window-title" id="' + id + '-title">' + inLanguages((t) => fileTitle(file, t)) + '</h2>' +
+        '<span class="chip tf-window-chip">' + e(file.path) + '</span></div>';
+    const row = (title, body) => '<section class="tf-fact"><h3 class="tf-h3">' + inLanguages((t) => t(title)) + '</h3>' + body + '</section>';
+    const body = '<div class="tf-window-body">' +
+        (file.reopened === undefined ? '' : backAgain(file)) +
+        row('fix.happened.did', '<p class="tf-fact-text">' + inLanguages((t) => t('fix.happened.' + did)) + '</p>') +
+        row('fix.window.where', whereList(file)) +
+        row('fix.window.todo', '<p class="tf-fact-text">' + inLanguages((t) => t('fix.happened.todo.' + did)) + '</p>') +
+        '</div>';
+    const foot = popupFoot(inLanguages((t) => t('fix.window.after')), pill({ label: inLanguages((t) => t('app.close')), tone: 'outline', size: 'md', button: true, attributes: CLOSES }) +
+        pill({ label: inLanguages((t) => t('fix.' + kind + '.go')), tone: 'primary', size: 'md', href: '#' + fixId(at), attributes: opener(fixId(at)) + ' data-fix-from' }));
+    return popup({ id, size: 'small', labelledBy: id + '-title', body: head + body + foot });
+}
+/** T12. */
+function backAgain(file) {
+    return callout({
+        tone: 'coral',
+        body: inLanguages((t, lang) => t('fix.window.back', { day: dayWord(file.reopened, t, lang) })),
+    });
+}
+/** T15: the conversations it was read in, newest first; six, then the rest behind "Show all". */
+function whereList(file) {
+    const shown = file.conversations;
+    const gone = file.count - shown.length;
+    const rows = shown.map((conversation, at) => {
+        const title = conversation.entry.title === undefined ? undefined : e(conversation.entry.title);
+        return '<li class="tf-where-row' + (at >= FIRST ? ' tf-more' : '') + '">' +
+            '<span class="tf-where-when"><span class="tf-where-day">' +
+            inLanguages((t, lang) => dayWord(conversation.when, t, lang, true)) +
+            '</span><span class="tf-where-time">' + conversation.when.time + '</span></span>' +
+            '<span class="tf-where-ask">' + (title ?? inLanguages((t) => t('fix.window.untitled'))) + '</span>' +
+            (conversation.report === undefined
+                ? '<span class="tf-where-none">' + inLanguages((t) => t('fix.window.noReport')) + '</span>'
+                : pill({ label: inLanguages((t) => t('fix.window.see')), tone: 'outline', href: e(conversation.report) })) +
+            '</li>';
+    }).join('');
+    return '<div class="tf-where-block"><ul class="tf-where" data-fix-where>' + rows + '</ul>' +
+        (shown.length > FIRST || gone > 0
+            ? '<div class="tf-where-foot">' +
+                (shown.length > FIRST
+                    ? '<button type="button" class="tf-all js-only" data-fix-all>' + inLanguages((t) => t('fix.window.all', { n: shown.length })) + '</button>'
+                    : '') +
+                (gone > 0 ? '<span class="tf-context">' + inLanguages((t) => t('fix.window.gone', { n: gone })) + '</span>' : '') +
+                '</div>'
+            : '') +
+        '</div>';
+}

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

@@ -0,0 +1,70 @@
+import { escapeHtml as e } from '../../render/html-report-components.js';
+import { inLanguages, labelAttributes } from '../../render/report-copy.js';
+import { pill } from '../../render/ui/button.js';
+import { callout } from '../../render/ui/callout.js';
+import { foldLine } from '../../render/ui/fold-line.js';
+import { fixId } from '../../render/report-page/to-do-view.js';
+import { opener, opens } from '../../render/ui/popup.js';
+import { tag } from '../../render/ui/tag.js';
+import { taskList } from '../../render/ui/task-list.js';
+import { happenedId } from './file-window.js';
+/** T6: what a file is, in words - the rule that matched it, else "A private file". */
+export function fileTitle(file, t) {
+    return t(file.name === undefined ? 'fix.private' : 'set.rule.' + file.name);
+}
+/**
+ * The To fix tab (T4-T8): keys to change, then a look to take, each hidden when empty, then the files whose name only
+ * was seen, folded. `numbered` gives each file the window number the page gave it.
+ */
+export function toFixList(view, numbered) {
+    const empty = view.keys.length === 0 && view.look.length === 0;
+    return (view.marksUnreadable ? callout({ tone: 'grey', body: inLanguages((t) => t('fix.marksUnreadable')) }) : '') +
+        group('keys', view.keys, numbered) +
+        group('look', view.look, numbered) +
+        (empty ? '<p class="tf-empty">' + inLanguages((t) => t('fix.empty')) + '</p>' : '') +
+        seenFold(view.seen);
+}
+const GROUP_LOOK = {
+    keys: { tone: 'coral', go: 'primary' },
+    look: { tone: 'amber', go: 'outline' },
+};
+function group(kind, files, numbered) {
+    if (files.length === 0)
+        return '';
+    const look = GROUP_LOOK[kind];
+    const tasks = files.map((file) => {
+        const at = numbered.get(file) ?? 0;
+        return {
+            title: inLanguages((t) => fileTitle(file, t)),
+            path: file.path,
+            done: false,
+            // The card as a whole opens Fix it; the pill says so, and is not a second control. "What happened" is one.
+            details: pill({ label: inLanguages((t) => t('rp.what')), tone: 'secondary', href: '#' + happenedId(at), attributes: opener(happenedId(at)) }),
+            action: pill({ label: inLanguages((t) => t('fix.' + kind + '.go')), tone: look.go }),
+            compact: {
+                bar: look.tone,
+                ...(file.reopened === undefined ? {} : { tag: tag(inLanguages((t) => t('fix.back')), 'coral', 'badge', true) }),
+                context: inLanguages((t) => t('fix.in', { n: file.count })),
+                opens: opens(fixId(at)),
+                label: labelAttributes((t) => e(fileTitle(file, t) + ' · ' + file.path)),
+            },
+        };
+    });
+    return '<section class="tf-group tf-group-' + look.tone + '">' +
+        '<div class="tf-group-head"><span class="tf-dot" aria-hidden="true"></span><h2 class="tf-h2">' +
+        inLanguages((t) => t('fix.' + kind)) + '</h2><span class="tf-group-count">' + files.length + '</span></div>' +
+        '<p class="tf-group-lead">' + inLanguages((t) => t('fix.' + kind + '.lead')) + '</p>' +
+        taskList(undefined, tasks) + '</section>';
+}
+/** T7: what only named a file asks nothing, so it is one folded line, and each file opened under it says so. */
+function seenFold(files) {
+    if (files.length === 0)
+        return '';
+    return foldLine({
+        summary: inLanguages((t) => t('fix.seen', { n: files.length })),
+        body: '<ul class="tf-seen">' + files.map((file) => '<li class="tf-seen-row"><span class="tf-seen-text"><span class="tf-seen-title">' + inLanguages((t) => fileTitle(file, t)) + '</span>' +
+            '<span class="tf-seen-sub"><span class="chip">' + e(file.path) + '</span><span class="tf-context">' +
+            inLanguages((t) => t('fix.in', { n: file.count })) + '</span></span></span>' +
+            '<span class="tf-seen-label">○ ' + inLanguages((t) => t('fix.seen.label')) + '</span></li>').join('') + '</ul>',
+    });
+}