@agentwhy/cli 0.0.0-dev

package/dist/report/start/serve/index-handler.js

@@ -0,0 +1,372 @@
+import { ALERT_THRESHOLDS } from '../../watch/agent-alert.js';
+import { CLEAN_MODES, NOTICE_CHANNELS, NOTICE_LANGS, SAID_AS } from '../../watch/notice-choices.js';
+import { isMarkResult, MARK_RESULTS } from '../../../ports/mark-store.js';
+import { onboardingChoices } from './onboarding-request.js';
+import { LANGS } from '../../render/report-copy.js';
+/** The one other value a page may send; anything else is the window, which asks nothing of the run it starts. */
+function switchFrom(value) {
+    return value === 'step' ? 'step' : 'window';
+}
+const TEXT = 'text/plain; charset=utf-8';
+const JSON_TYPE = 'application/json; charset=utf-8';
+const VERSION_ROUTE = 'api/version/';
+/**
+ * A page with its version on its root element (L2), and for the index how many conversations it was sent with, so the
+ * pill can say how many are new (L8). A version is base 36 and a count a number: neither needs escaping.
+ */
+function withVersion(html, version) {
+    const count = version.conversations === undefined ? '' : ' data-conversations="' + version.conversations + '"';
+    return html.replace(/<html /, '<html data-version="' + version.version + '"' + count + ' ');
+}
+/**
+ * The page's server as a function of a request (`worth-running-every-day` R50-R53): a name it was not given, a path
+ * without the token, a file this run did not write, a write from another origin - each gets nothing. What is left is
+ * reading the pages and the two writes a person can make from them.
+ */
+export function indexHandler(dependencies) {
+    const { origin, token } = dependencies;
+    const host = origin.replace(/^http:\/\//, '');
+    const prefix = `/${token}/`;
+    return async (request) => {
+        // A name that merely resolves to this machine is not the address the page was opened on (DNS rebinding).
+        if (request.headers.host !== host)
+            return { status: 403, type: TEXT, body: 'Forbidden.' };
+        if (!request.path.startsWith(prefix)) {
+            const other = /^\/([^/]+)\/(.*)$/.exec(request.path);
+            const past = other === null ? undefined : dependencies.pastRun?.(other[1] ?? '');
+            return past === undefined ? notFound() : pastRunAnswer(past, other?.[2] ?? '', request, dependencies, prefix);
+        }
+        const rest = request.path.slice(prefix.length);
+        if (request.method === 'GET') {
+            // live-pages L3: a page asks whether its file is still the version it was sent. The refresh ran before this
+            // handler was reached (the server runs it for every page and every version asked for); this only answers.
+            if (rest.startsWith(VERSION_ROUTE)) {
+                // Empty is the page opened at the served root: the index, as a `GET` of the root is.
+                const asked = rest.slice(VERSION_ROUTE.length) || 'index.html';
+                const version = dependencies.files.has(asked) ? dependencies.versionOf?.(asked) : undefined;
+                return version === undefined ? notFound() : { status: 200, type: JSON_TYPE, body: JSON.stringify(version) };
+            }
+            const name = rest === '' ? 'index.html' : rest;
+            if (!dependencies.files.has(name))
+                return notFound();
+            const body = await dependencies.read(name);
+            // L2: the page carries the version it was sent at, added as it is sent, so the file on disk - and the version
+            // hashed from it - is exactly what the renderer wrote.
+            const version = dependencies.versionOf?.(name);
+            return { status: 200, type: 'text/html; charset=utf-8', body: version === undefined ? body : withVersion(body, version) };
+        }
+        const routes = [
+            'api/mark',
+            'api/unmark',
+            ...(dependencies.settings === undefined ? [] : ['api/settings']),
+            ...(dependencies.notify === undefined ? [] : ['api/notify']),
+            ...(dependencies.include === undefined ? [] : ['api/include']),
+            ...(dependencies.onboarding === undefined ? [] : ['api/onboarding']),
+            ...(dependencies.switchProject === undefined ? [] : ['api/switch-project']),
+            ...(dependencies.chooseFolder === undefined ? [] : ['api/choose-folder']),
+        ];
+        if (request.method !== 'POST' || !routes.includes(rest))
+            return notFound();
+        if (request.headers.origin !== origin)
+            return { status: 403, type: TEXT, body: 'Forbidden.' };
+        if (!(request.headers['content-type'] ?? '').startsWith('application/json'))
+            return { status: 415, type: TEXT, body: 'JSON only.' };
+        let body;
+        try {
+            body = JSON.parse(request.body);
+        }
+        catch {
+            return reply(400, 'The request was not JSON.');
+        }
+        if (body === null || typeof body !== 'object')
+            return reply(400, 'The request was not an object.');
+        const fields = body;
+        if (rest === 'api/notify') {
+            const change = noticeChange(fields);
+            if (typeof change === 'string')
+                return reply(400, change);
+            const answer = await dependencies.notify(change);
+            if (!answer.written)
+                return reply(500, answer.said);
+            await dependencies.rerender();
+            return { status: 200, type: JSON_TYPE, body: JSON.stringify({ ok: true, message: answer.said }) };
+        }
+        if (rest === 'api/choose-folder') {
+            const lang = LANGS.find((one) => one === fields.lang) ?? 'en';
+            const answer = await dependencies.chooseFolder(lang, switchFrom(fields.from));
+            if (answer.kind === 'failed')
+                return reply(422, answer.reason);
+            // A folder switched to is this run's end, as a switch by id is (V18): the answer is sent whole first.
+            return {
+                status: 200,
+                type: JSON_TYPE,
+                body: JSON.stringify({ ok: true, ...answer }),
+                ...(answer.kind === 'switched' && dependencies.switched !== undefined ? { after: dependencies.switched } : {}),
+            };
+        }
+        if (rest === 'api/switch-project') {
+            if (typeof fields.id !== 'string' || fields.id === '' || fields.id.length > 1024)
+                return reply(400, 'A project is named.');
+            const answer = await dependencies.switchProject(fields.id, switchFrom(fields.from));
+            if ('failed' in answer)
+                return reply(422, answer.failed);
+            // The answer is sent whole before this run's server closes: closing first would cut it.
+            return { status: 200, type: JSON_TYPE, body: JSON.stringify({ ok: true, url: answer.url }), ...(dependencies.switched === undefined ? {} : { after: dependencies.switched }) };
+        }
+        if (rest === 'api/include') {
+            // F55: one name, and nothing else; whether it may be written is the run's to say, which lists what it left out.
+            if (typeof fields.name !== 'string' || fields.name === '' || fields.name.length > 200)
+                return reply(400, 'A conversation is named.');
+            const answer = await dependencies.include(fields.name);
+            if (!answer.written)
+                return reply(422, answer.said);
+            await dependencies.rerender();
+            return { status: 200, type: JSON_TYPE, body: JSON.stringify({ ok: true, message: answer.said }) };
+        }
+        if (rest === 'api/onboarding') {
+            const choices = onboardingChoices(fields);
+            if (typeof choices === 'string')
+                return reply(400, choices);
+            const answer = await dependencies.onboarding(choices);
+            // A name that cannot be written refuses the whole request: nothing was written, nothing recorded (R59).
+            if (answer.outcome === 'refused')
+                return reply(422, answer.message);
+            // Handled, whatever each change answered: the page names the ones that failed (W20), and every page is read again.
+            await dependencies.rerender();
+            return { status: 200, type: JSON_TYPE, body: JSON.stringify({ ok: true, results: answer.results, recorded: answer.recorded, ...(answer.codex === undefined ? {} : { codex: answer.codex }) }) };
+        }
+        if (rest === 'api/settings') {
+            const change = settingsChange(fields);
+            if (typeof change === 'string')
+                return reply(400, change);
+            // R58: the page's confirm step is the consent, so the same setup a terminal runs is run with `yes`.
+            const answer = await dependencies.settings(change);
+            // R59: a refusal says why and writes nothing; R60: a write is followed by the page being read again.
+            if (answer.outcome !== 'written' && answer.outcome !== 'unchanged') {
+                return reply(answer.outcome === 'refused' ? 422 : 500, answer.output.trim());
+            }
+            await dependencies.rerender();
+            return { status: 200, type: JSON_TYPE, body: JSON.stringify({ ok: true, message: answer.output.trim() }) };
+        }
+        if (typeof fields.path !== 'string' || fields.path === '')
+            return reply(400, 'A path is required.');
+        let answer;
+        if (rest === 'api/mark') {
+            const result = fields.result;
+            if (!isMarkResult(result))
+                return reply(400, `The result is ${MARK_RESULTS.join(', ')}.`);
+            if (fields.note !== undefined && typeof fields.note !== 'string')
+                return reply(400, 'A note is text.');
+            answer = await dependencies.mark({
+                path: fields.path,
+                result,
+                ...(typeof fields.note === 'string' && fields.note.trim() !== '' ? { note: fields.note } : {}),
+            });
+        }
+        else {
+            answer = await dependencies.unmark(fields.path);
+        }
+        if (answer.outcome !== 'marked')
+            return reply(answer.outcome === 'mark-refused' ? 422 : 500, answer.output.trim());
+        await dependencies.rerender();
+        return { status: 200, type: JSON_TYPE, body: JSON.stringify({ ok: true, message: answer.output.trim() }) };
+    };
+}
+/**
+ * R57: one change per request, in the shape `--watch`/`--refuse`/`--protect`/`--unprotect` already give the command
+ * line, plus the change of a pattern, which is those last two in order. A body this does not recognise is answered
+ * as the bad request it is, and nothing is written.
+ */
+function settingsChange(fields) {
+    // Which of the project's two settings files the change is to. Absent is the local one, which is what `init`
+    // writes when `--shared` is not given; anything else is a body this server does not recognise.
+    if (fields.where !== undefined && fields.where !== 'local' && fields.where !== 'shared') {
+        return 'The file is local or shared.';
+    }
+    const where = fields.where === 'shared' ? { where: 'shared' } : {};
+    if (fields.change === 'hooks') {
+        if (!Array.isArray(fields.hooks))
+            return 'The hooks are a list.';
+        const hooks = fields.hooks.filter((hook) => hook === 'watch' || hook === 'refuse');
+        if (hooks.length !== fields.hooks.length)
+            return 'A hook is watch or refuse.';
+        if (hooks.length === 0)
+            return 'A hook is required.';
+        if (typeof fields.on !== 'boolean')
+            return 'The direction is true or false.';
+        return { change: 'hooks', hooks, on: fields.on, ...where };
+    }
+    // The built-in list, written into the project. The patterns are named by the page rather than taken on trust
+    // from a body: a request that could name any pattern at all would be a way to write rules nobody chose.
+    if (fields.change === 'adopt') {
+        if (fields.where !== 'local' && fields.where !== 'shared')
+            return 'A change names the file it writes.';
+        if (!Array.isArray(fields.patterns) || fields.patterns.length === 0)
+            return 'The patterns are a list.';
+        const patterns = fields.patterns.filter((pattern) => typeof pattern === 'string' && pattern.trim() !== '');
+        if (patterns.length !== fields.patterns.length)
+            return 'A pattern is text.';
+        return { change: 'adopt', patterns: patterns.map((pattern) => pattern.trim()), where: fields.where };
+    }
+    // F57: one row's switch. The patterns and the rules are the page's, named as `adopt` names its patterns.
+    if (fields.change === 'mode') {
+        if (fields.where !== 'local' && fields.where !== 'shared')
+            return 'A change names the file it writes.';
+        if (fields.to !== 'block' && fields.to !== 'tell' && fields.to !== 'none')
+            return 'The mode is block, tell or none.';
+        if (!Array.isArray(fields.patterns) || fields.patterns.length === 0 || !Array.isArray(fields.rules))
+            return 'The patterns and the rules are lists.';
+        const patterns = fields.patterns.filter((pattern) => typeof pattern === 'string' && pattern.trim() !== '');
+        const rules = fields.rules.filter((rule) => typeof rule === 'string' && rule.trim() !== '');
+        if (patterns.length !== fields.patterns.length || rules.length !== fields.rules.length)
+            return 'A pattern is text.';
+        return { change: 'mode', to: fields.to, patterns: patterns.map((pattern) => pattern.trim()), rules: rules.map((rule) => rule.trim()), where: fields.where };
+    }
+    // General (F56): the rules and the hooks the page names, into one file. As with `adopt`, the page names them.
+    if (fields.change === 'scope') {
+        if (fields.where !== 'local' && fields.where !== 'shared')
+            return 'A change names the file it writes.';
+        if (!Array.isArray(fields.patterns) || !Array.isArray(fields.hooks))
+            return 'The patterns and the hooks are lists.';
+        const patterns = fields.patterns.filter((pattern) => typeof pattern === 'string' && pattern.trim() !== '');
+        if (patterns.length !== fields.patterns.length)
+            return 'A pattern is text.';
+        const hooks = fields.hooks.filter((hook) => hook === 'watch' || hook === 'refuse');
+        if (hooks.length !== fields.hooks.length)
+            return 'A hook is watch or refuse.';
+        if (patterns.length === 0 && hooks.length === 0)
+            return 'A change sets something.';
+        return { change: 'scope', patterns: patterns.map((pattern) => pattern.trim()), hooks, where: fields.where };
+    }
+    // F59: both hooks out of each file named, with the rules the page names for it. A file named with no rules still has
+    // its hooks taken out; a body that names no file at all asks for nothing.
+    if (fields.change === 'uninstall') {
+        const named = fields.rules;
+        if (typeof named !== 'object' || named === null || Array.isArray(named))
+            return 'The rules are listed by file.';
+        const rules = {};
+        for (const [file, list] of Object.entries(named)) {
+            if (file !== 'local' && file !== 'shared')
+                return 'The file is local or shared.';
+            if (!Array.isArray(list))
+                return 'The rules are a list.';
+            const patterns = list.filter((pattern) => typeof pattern === 'string' && pattern.trim() !== '');
+            if (patterns.length !== list.length)
+                return 'A pattern is text.';
+            rules[file] = patterns.map((pattern) => pattern.trim());
+        }
+        if (Object.keys(rules).length === 0)
+            return 'An uninstall names the files it takes agentwhy out of.';
+        return { change: 'uninstall', rules };
+    }
+    // The same rule, in the other file. `where` is the destination and is required here: a move with no file named
+    // is not a move. A hook is moved by a `hooks` change instead, which names the file it is to run from.
+    if (fields.change === 'move') {
+        if (fields.where !== 'local' && fields.where !== 'shared')
+            return 'A move names the file it goes to.';
+        const to = fields.where;
+        if (typeof fields.pattern !== 'string' || fields.pattern.trim() === '')
+            return 'A pattern is required.';
+        if (fields.from !== 'local' && fields.from !== 'shared')
+            return 'A move names the file it comes from.';
+        return { change: 'move', pattern: fields.pattern.trim(), from: fields.from, where: to };
+    }
+    // U7: the update notice names nothing; what it pins, and to what, the setup reads for itself.
+    if (fields.change === 'update')
+        return { change: 'update' };
+    if (fields.change === 'codex')
+        return { change: 'codex' };
+    if (fields.change === 'protect' || fields.change === 'unprotect' || fields.change === 'edit') {
+        if (typeof fields.pattern !== 'string' || fields.pattern.trim() === '')
+            return 'A pattern is required.';
+        if (fields.change !== 'edit')
+            return { change: fields.change, pattern: fields.pattern.trim(), ...where };
+        if (typeof fields.from !== 'string' || fields.from.trim() === '')
+            return 'The pattern being changed is required.';
+        return { change: 'edit', from: fields.from.trim(), pattern: fields.pattern.trim(), ...where };
+    }
+    return 'The change is hooks, protect, unprotect, edit, move, adopt, scope, mode, uninstall or update.';
+}
+/**
+ * R26a: the scope, and the answers to set - or that they are to be taken out. Nothing else about a person or a
+ * project goes in the body, and a value this version does not know is a bad request rather than a choice half
+ * written: someone believing they are told more than they are is the failure this whole feature exists against.
+ */
+function noticeChange(fields) {
+    if (fields.scope !== 'project' && fields.scope !== 'everywhere')
+        return 'The scope is project or everywhere.';
+    const scope = fields.scope;
+    const on = oneOf(fields.on, ALERT_THRESHOLDS);
+    const clean = oneOf(fields.clean, CLEAN_MODES);
+    const say = oneOf(fields.say, SAID_AS);
+    const notify = channelsIn(fields.notify);
+    const lang = oneOf(fields.lang, NOTICE_LANGS);
+    if (on === 'unknown')
+        return `A level is ${ALERT_THRESHOLDS.join(', ')}.`;
+    if (clean === 'unknown')
+        return `A quiet turn is ${CLEAN_MODES.join(', ')}.`;
+    if (say === 'unknown')
+        return `A value is said as ${SAID_AS.join(' or ')}.`;
+    if (notify === 'unknown')
+        return `A channel is ${NOTICE_CHANNELS.join(', ')}.`;
+    if (lang === 'unknown')
+        return `A language is ${NOTICE_LANGS.join(', ')}.`;
+    const choices = {
+        ...(on === undefined ? {} : { on }),
+        ...(clean === undefined ? {} : { clean }),
+        ...(say === undefined ? {} : { say }),
+        ...(notify === undefined ? {} : { notify }),
+        ...(lang === undefined ? {} : { lang }),
+    };
+    // Mirrors the CLI's `--reset`: it takes answers out, and is refused rather than guessed at where a choice came
+    // with it. Checked after the fields are read, so a choice this version does not know is still the error said -
+    // and checked before `choices` is dropped, so a choice given alongside `reset` is never silently lost.
+    if (fields.reset === true) {
+        return Object.keys(choices).length > 0
+            ? 'A reset takes answers out; it cannot be given alongside a choice.'
+            : { scope, choices: {}, reset: true };
+    }
+    return Object.keys(choices).length === 0 ? 'A change sets something, or resets.' : { scope, choices };
+}
+function oneOf(value, known) {
+    if (value === undefined)
+        return undefined;
+    return known.find((candidate) => candidate === value) ?? 'unknown';
+}
+function channelsIn(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.length === 0)
+        return 'unknown';
+    const channels = value.map((name) => NOTICE_CHANNELS.find((channel) => channel === name));
+    return channels.includes(undefined) ? 'unknown' : [...new Set(channels)];
+}
+/**
+ * The pages of a project shown earlier in this process (V14, amended). The project shown again since: its pages are sent
+ * to this run's address. Another: a page is "This page was for my-app", a page open in a tab that asks whether it
+ * changed is told it has gone for good (410, so it says so at once, L13), and the only thing it may ask is the way back -
+ * from its own origin, as every write. Nothing else is read or written from it (V17).
+ */
+async function pastRunAnswer(past, rest, request, dependencies, prefix) {
+    if (past.same)
+        return request.method === 'GET' ? { status: 302, type: TEXT, body: '', location: prefix + rest } : notFound();
+    if (request.method === 'GET') {
+        if (rest.startsWith('api/'))
+            return { status: 410, type: JSON_TYPE, body: JSON.stringify({ gone: true }) };
+        return { status: 200, type: 'text/html; charset=utf-8', body: await past.page() };
+    }
+    if (request.method !== 'POST' || rest !== 'api/switch-back')
+        return notFound();
+    if (request.headers.origin !== dependencies.origin)
+        return { status: 403, type: TEXT, body: 'Forbidden.' };
+    const answer = await past.back();
+    if ('failed' in answer)
+        return reply(422, answer.failed);
+    return { status: 200, type: JSON_TYPE, body: JSON.stringify({ ok: true, url: answer.url }), ...(dependencies.switched === undefined ? {} : { after: dependencies.switched }) };
+}
+function notFound() {
+    return { status: 404, type: TEXT, body: 'Not found.' };
+}
+function reply(status, message) {
+    return { status, type: JSON_TYPE, body: JSON.stringify({ ok: false, message }) };
+}

package/dist/report/start/serve/onboarding-request.js

@@ -0,0 +1,50 @@
+/** W15: a person adds a few files while setting up; more than this in one request is not a page that was used. */
+export const MOST_NAMES = 20;
+const FIELDS = ['scope', 'watch', 'protect', 'tell', 'modes', 'stopped', 'fine'];
+/**
+ * The body of `api/onboarding` (`.ai/specs/2026-09-24-onboarding.md` W15): exactly the three steps' answers, and
+ * nothing else. A body this does not recognise is a bad request, and nothing is written - a request that could carry
+ * more than the page offers would be a way to write what nobody chose. Whether a name can be written is not decided
+ * here: `finishOnboarding` refuses the whole request where one cannot (R46, R59).
+ */
+export function onboardingChoices(fields) {
+    const unknown = Object.keys(fields).filter((key) => !FIELDS.includes(key));
+    if (unknown.length > 0)
+        return 'The request holds ' + FIELDS.join(', ') + ', and nothing else.';
+    if (fields.scope !== 'local' && fields.scope !== 'shared')
+        return 'The scope is local or shared.';
+    if (typeof fields.watch !== 'boolean' || typeof fields.stopped !== 'boolean' || typeof fields.fine !== 'boolean') {
+        return 'watch, stopped and fine are true or false.';
+    }
+    const protect = names(fields.protect);
+    const tell = names(fields.tell);
+    if (typeof protect === 'string')
+        return protect;
+    if (typeof tell === 'string')
+        return tell;
+    if (protect.length + tell.length > MOST_NAMES)
+        return `At most ${MOST_NAMES} names are added at once.`;
+    // W12a: a row's mode by its key. The key only finds a row the server reads again; it writes nothing of its own.
+    if (fields.modes === null || typeof fields.modes !== 'object' || Array.isArray(fields.modes))
+        return 'The modes are an object.';
+    const modes = Object.entries(fields.modes);
+    if (modes.length > MOST_NAMES || modes.some(([key, mode]) => key.length > 200 || (mode !== 'block' && mode !== 'tell')))
+        return 'A mode is block or tell.';
+    return {
+        scope: fields.scope,
+        watch: fields.watch,
+        protect,
+        tell,
+        modes: Object.fromEntries(modes),
+        stopped: fields.stopped,
+        fine: fields.fine,
+    };
+}
+function names(value) {
+    if (!Array.isArray(value))
+        return 'The names are a list.';
+    const kept = value.filter((pattern) => typeof pattern === 'string' && pattern.trim() !== '');
+    if (kept.length !== value.length)
+        return 'A name is text.';
+    return kept.map((pattern) => pattern.trim());
+}

package/dist/report/start/serve/settings-request.js

@@ -0,0 +1 @@
+export {};

package/dist/report/start/serve/settings-setup.js

@@ -0,0 +1,193 @@
+import { patternsOf } from '../../../setup/protected-patterns.js';
+/**
+ * One change from the served Settings view, as the `SetupOptions` the equivalent `init` flags would build
+ * (`worth-running-every-day` R58). Nothing new decides what is written: this only chooses the flags, and the
+ * setup a terminal runs does the rest.
+ *
+ * `yes` is given because the page's own confirm step (R56) is the consent R7 asks for, off a terminal; the setup
+ * is built with `interactive: false`, so no question is ever opened.
+ */
+export async function settingsChangeToSetup(setup, change) {
+    // A pattern `init` would not write is refused here, before anything runs (R46, R59). `init` itself only says "Not
+    // written" and goes on with the rest - an answer that reads as success, and a page that reloads on success would
+    // show the list unchanged with no reason at all.
+    const refused = patternsOf(patternsIn(change)).refused;
+    if (refused.length > 0) {
+        return { outcome: 'refused', output: refused.map(({ pattern, reason }) => `"${pattern}" was not written: ${reason}.`).join('\n') };
+    }
+    // U7: `init --update`, the same run a terminal makes; the setup reads both files and the version itself.
+    if (change.change === 'update') {
+        const result = await setup.run({ ...base(undefined), update: true });
+        return { outcome: result.outcome, output: result.output };
+    }
+    // CK5: `init --codex`; the setup reads what Claude Code's `refuse` runs, and writes Codex's to match.
+    if (change.change === 'codex') {
+        const result = await setup.run({ ...base(undefined), codex: true });
+        return { outcome: result.outcome, output: result.output };
+    }
+    if (change.change === 'adopt') {
+        // One run: `init --protect … --refuse`, keeping every other hook as it runs. A private file is kept from the
+        // agent's searches as well as from being opened (F38, amended 2026-09-24): `refuse` is what stops a `grep -r`
+        // that the deny rule never sees, and it is installed with the rules rather than asked for on a tab of its own.
+        const result = await setup.run({ ...base(change.where), hooks: ['refuse'], keep: true, protect: [...change.patterns] });
+        return { outcome: result.outcome, output: result.output };
+    }
+    if (change.change === 'scope')
+        return scope(setup, change);
+    if (change.change === 'uninstall')
+        return uninstall(setup, change);
+    if (change.change === 'mode')
+        return { outcome: 'refused', output: 'This page cannot change what is told: agentwhy has no told lists to write here.' };
+    if (change.change === 'move')
+        return move(setup, change);
+    if (change.change === 'edit')
+        return edit(setup, change.from, change.pattern, change.where);
+    // An add is what the Add window confirmed: "your AI won't be able to open it or search through it" (F38).
+    const result = await setup.run(change.change === 'protect' ? { ...optionsFor(change), hooks: ['refuse'], keep: true } : optionsFor(change));
+    return { outcome: result.outcome, output: result.output };
+}
+/**
+ * Changing a pattern: the old rule out, then the new one in. `init` has no flag that rewrites a rule in place, so
+ * this is the two runs a terminal would do, in that order. The first failing stops the second, so a change that
+ * cannot take the old rule out never leaves both patterns protected; the page then says what went wrong and the
+ * file is as it was.
+ */
+async function edit(setup, from, pattern, where) {
+    const out = await setup.run(optionsFor({ change: 'unprotect', pattern: from, ...(where === undefined ? {} : { where }) }));
+    if (out.outcome !== 'written' && out.outcome !== 'unchanged')
+        return { outcome: out.outcome, output: out.output };
+    // The new rule goes back into the file the old one came out of, so changing a rule never moves it between the
+    // file that is this machine's and the one the project shares.
+    const back = await setup.run(optionsFor({ change: 'protect', pattern, ...(where === undefined ? {} : { where }) }));
+    return { outcome: back.outcome, output: [out.output.trim(), back.output.trim()].filter((line) => line !== '').join('\n') };
+}
+/**
+ * The same rule, in the other file: the deny rule out of the file that holds it, then in to the other, in that
+ * order, because nothing removes a deny rule except `--remove --unprotect`. The first failing stops the second,
+ * so a move that cannot take the old rule out never leaves the same rule in both files.
+ */
+async function move(setup, change) {
+    const out = await setup.run(optionsFor({ change: 'unprotect', pattern: change.pattern, where: change.from }));
+    if (out.outcome !== 'written' && out.outcome !== 'unchanged')
+        return { outcome: out.outcome, output: out.output };
+    const back = await setup.run(optionsFor({ change: 'protect', pattern: change.pattern, where: change.where }));
+    return { outcome: back.outcome, output: [out.output.trim(), back.output.trim()].filter((line) => line !== '').join('\n') };
+}
+/**
+ * General (F56): the rules first, each moved as `move` moves one, then the hooks, installed in the file they are to run
+ * from - which takes them out of the other (R4g) and points them at the rules now there. The first failure stops the
+ * rest and is said: what was moved before it stays moved, and every rule is in one file or the other, never neither.
+ */
+async function scope(setup, change) {
+    const from = change.where === 'shared' ? 'local' : 'shared';
+    const said = [];
+    for (const pattern of change.patterns) {
+        const moved = await move(setup, { change: 'move', pattern, from, where: change.where });
+        said.push(moved.output.trim());
+        if (moved.outcome !== 'written' && moved.outcome !== 'unchanged')
+            return { outcome: moved.outcome, output: said.filter(Boolean).join('\n') };
+    }
+    if (change.hooks.length > 0) {
+        const hooks = await setup.run({ ...base(change.where), hooks: change.hooks, keep: true });
+        said.push(hooks.output.trim());
+        if (hooks.outcome !== 'written' && hooks.outcome !== 'unchanged')
+            return { outcome: hooks.outcome, output: said.filter(Boolean).join('\n') };
+    }
+    return { outcome: said.length === 0 ? 'unchanged' : 'written', output: said.filter(Boolean).join('\n') };
+}
+/**
+ * F59: `init --remove --watch --refuse --unprotect …` for each file the page named, the local one first. The first
+ * failure stops the rest and is said: a file already done stays done, and the page, read again, shows what is left.
+ */
+async function uninstall(setup, change) {
+    const said = [];
+    let written = false;
+    for (const file of ['local', 'shared']) {
+        const rules = change.rules[file];
+        if (rules === undefined)
+            continue;
+        const out = await setup.run({ ...base(file), remove: true, hooks: ['watch', 'refuse'], unprotect: [...rules] });
+        said.push(out.output.trim());
+        if (out.outcome !== 'written' && out.outcome !== 'unchanged')
+            return { outcome: out.outcome, output: said.filter(Boolean).join('\n') };
+        written ||= out.outcome === 'written';
+    }
+    return { outcome: written ? 'written' : 'unchanged', output: said.filter(Boolean).join('\n') };
+}
+/**
+ * Whether a change only takes something out: the one change the setup makes where no project is (`which-project.md`
+ * V8), since what an earlier agentwhy wrote there has to be removable. Every other change writes something, and an edit,
+ * a move, General's scope and a switch to Block or Tell me take something out first - refused only at the step that
+ * writes, each left the file neither protected nor told. Found by a review.
+ */
+export function onlyTakesOut(change) {
+    return change.change === 'uninstall' || change.change === 'unprotect' || (change.change === 'hooks' && !change.on);
+}
+/** The patterns a change writes: the ones it protects, and what an edited rule becomes. */
+function patternsIn(change) {
+    if (change.change === 'adopt' || change.change === 'scope' || change.change === 'mode')
+        return change.patterns;
+    if (change.change === 'protect' || change.change === 'edit')
+        return [change.pattern];
+    return [];
+}
+/** What every change here has in common: it writes one named file, and the page's confirm step is the consent. */
+function base(where) {
+    // Where the change says nothing, it is the file `init` writes when `--shared` is not given: this page's own
+    // default, and the one a pattern typed into the add field goes to. No `invoke`: the setup settles the command a
+    // hook runs, for this page as for `init` (`a-hook-runs-what-you-ran.md` J1).
+    return { protect: [], remove: false, yes: true, target: where ?? 'local' };
+}
+function optionsFor(change) {
+    const base_ = base(change.where);
+    if (change.change === 'hooks') {
+        // On installs the hook named and leaves the other as the file has it (`keep`: `init --watch` alone would take a
+        // running `refuse` out, R4b); `init --remove --watch` takes out that one hook and leaves every deny rule. Turning
+        // a switch on or off is one of those two and nothing else.
+        return change.on
+            ? { ...base_, hooks: change.hooks, keep: true }
+            : { ...base_, remove: true, hooks: change.hooks };
+    }
+    // Both name no hook, so both name the empty set of them. Left unsaid, `init` off a terminal installs `watch`
+    // and `--remove` takes every hook out - neither of which the confirm step offered, and R41 says a change
+    // touches only what it names. An add names `refuse` itself, in `settingsChangeToSetup`; an edit or a move of a rule
+    // that is already there does not: it stays the block it was, and where that was not whole, its row says so and
+    // **Finish blocking** closes it (`block-means-blocked` K3, K7).
+    return change.change === 'protect'
+        ? { ...base_, hooks: [], protect: [change.pattern] }
+        : { ...base_, remove: true, hooks: [], unprotect: [change.pattern] };
+}
+/**
+ * F57's switch, where the told lists can be written. To `tell`: every deny rule named comes out of both files - a rule
+ * left in either would still stop the agent - then the patterns go on the list General points at. To `block`: the
+ * patterns come off both lists first, then are protected as an add is, `refuse` with them. The first failure stops the
+ * rest and is said; a file is never left both off the rules and off the lists.
+ */
+export async function modeChange(setup, lists, change) {
+    const refused = patternsOf(change.patterns).refused;
+    if (refused.length > 0)
+        return { outcome: 'refused', output: refused.map(({ pattern, reason }) => `"${pattern}" was not written: ${reason}.`).join('\n') };
+    const said = [];
+    const failed = (outcome) => outcome !== 'written' && outcome !== 'unchanged';
+    if (change.to === 'tell') {
+        for (const file of ['local', 'shared']) {
+            if (change.rules.length === 0)
+                break;
+            const out = await setup.run({ ...base(file), remove: true, hooks: [], unprotect: [...change.rules] });
+            said.push(out.output.trim());
+            if (failed(out.outcome))
+                return { outcome: out.outcome, output: said.filter(Boolean).join('\n') };
+        }
+        if (!(await lists.change(change.where, change.patterns, [])))
+            return { outcome: 'unwritable', output: 'The list of files to tell you about could not be written.' };
+        return { outcome: 'written', output: said.filter(Boolean).join('\n') };
+    }
+    for (const file of ['local', 'shared']) {
+        if (!(await lists.change(file, [], change.patterns)))
+            return { outcome: 'unwritable', output: 'The list of files to tell you about could not be written.' };
+    }
+    if (change.to === 'none')
+        return { outcome: 'written', output: '' };
+    const back = await setup.run({ ...base(change.where), hooks: ['refuse'], keep: true, protect: [...change.patterns] });
+    return { outcome: back.outcome, output: back.output };
+}

package/dist/report/start/session-index.js

@@ -0,0 +1 @@
+export {};