@agentwhy/cli 0.1.0 → 0.2.1

package/dist/refuse/command-refusal.js

@@ -1,14 +1,13 @@
-import { isAbsolute, join, dirname } from 'node:path';
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
+import { isAbsolute, join } from 'node:path';
 import { parsePreToolUseInput } from '../adapter/claude-code/hooks/pre-tool-use-input.js';
-import { PROJECT_HOOKS } from '../adapter/codex/contract/hooks.js';
+import { refuseProjectAbove, refuseRulesOf } from '../adapter/claude-code/settings/refuse-project.js';
 import { parseCodexPreToolUseInput } from '../adapter/codex/hooks/pre-tool-use-input.js';
 import { protectedPathsInCommand } from '../core/access/protected-access.js';
-import { FileAccessError } from '../ports/file-access-error.js';
 import { choosePolicy } from '../report/choose-policy.js';
 import { blockingOnly } from '../core/policy/policy.js';
 import { protectedFileReached } from './command-reach.js';
-/** How many folders above the session's the project is looked for in: deeper than any project, short of a loop. */
-const MAX_PROJECT_DEPTH = 64;
 /** A command line is a few kilobytes; past this the input is not held at all, and the command is not checked. */
 const MAX_INPUT_BYTES = 1024 * 1024;
 /**
@@ -32,6 +31,10 @@ export class CommandRefusal {
         if ('anotherTool' in parsed)
             return { kind: 'allow' };
         const settled = codex ? await this.#inCodexProject(choice, parsed.cwd ?? this.#dependencies.workingDirectory) : choice;
+        // AO6: the computer-wide check runs in every Codex session; where no project above runs `refuse`, there are no
+        // rules anybody chose here, and the command runs with no message.
+        if (settled === 'no-project')
+            return { kind: 'allow' };
         if (settled === undefined)
             return { kind: 'not-checked', reason: 'project' };
         const chosen = await choosePolicy(settled, this.#dependencies.files, this.#dependencies.tell);
@@ -55,34 +58,20 @@ export class CommandRefusal {
         return { kind: 'refuse', path: reach.path, pattern: reach.pattern, others: 0, route };
     }
     /**
-     * CK3: Codex runs its hook in the session's folder, which can lie below the project, and names the project nowhere
-     * (CKB6). A relative settings path is read in the project: the nearest folder, at or above `folder`, that holds the
-     * `.codex/hooks.json` this hook is written in. None found is `undefined`: the command runs, and is said to be unchecked.
+     * CK3, AO5, AO6: Codex runs its check in the session's folder, which can lie below the project, and names the
+     * project nowhere (CKB6). The project is the nearest folder at or above `folder`, short of the home directory, whose
+     * Claude Code settings run `refuse`. With no flag of its own, the check reads the rules that project's `refuse`
+     * names, and with no project found it is `'no-project'`: the command runs, silently. A relative `--settings`, as an
+     * older project-level entry wrote it, resolves against the same project; none found is `undefined`, and the command
+     * runs said to be unchecked (R20). An absolute path or a policy file is read as given.
      */
     async #inCodexProject(choice, folder) {
         const relative = choice.settingsPath;
-        if (relative === undefined || isAbsolute(relative))
+        if (choice.policyPath !== undefined || (relative !== undefined && isAbsolute(relative)))
             return choice;
-        for (let at = folder, depth = 0; depth < MAX_PROJECT_DEPTH; depth += 1) {
-            if (await this.#holds(join(at, PROJECT_HOOKS.directory, PROJECT_HOOKS.file)))
-                return { ...choice, settingsPath: join(at, relative) };
-            const up = dirname(at);
-            if (up === at)
-                return undefined;
-            at = up;
-        }
-        return undefined;
-    }
-    /** Whether a file is there to read; a folder or anything unreadable is not. */
-    async #holds(path) {
-        try {
-            await this.#dependencies.files.readText(path);
-            return true;
-        }
-        catch (error) {
-            if (error instanceof FileAccessError)
-                return false;
-            throw error;
-        }
+        const found = await refuseProjectAbove(this.#dependencies.files, folder, this.#dependencies.home);
+        if (relative !== undefined)
+            return found === undefined ? undefined : { ...choice, settingsPath: join(found.project, relative) };
+        return found === undefined ? 'no-project' : refuseRulesOf(found);
     }
 }

package/dist/refuse/render/refusal-words.js

@@ -1,10 +1,12 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 import { HOOK_OUTPUT } from '../../adapter/claude-code/contract/hooks.js';
 const NOT_CHECKED = {
     arguments: 'agentwhy refuse was given arguments it does not recognise, so this command was not checked.',
     input: 'agentwhy refuse could not read the hook input, so this command was not checked.',
     policy: 'agentwhy refuse could not read the policy it was given, so this command was not checked.',
     search: 'agentwhy refuse could not look through everything this search reaches, so this command was not checked.',
-    project: 'agentwhy refuse found no .codex/hooks.json in this folder or above it, so it could not read the project\'s rules and this command was not checked.',
+    project: 'agentwhy refuse found no project above this folder whose Claude Code settings run refuse, so it could not read the rules it was pointed at and this command was not checked.',
 };
 /** Said to the user, as a hook's JSON on stdout, when a command ran without being checked (R20). */
 export function notCheckedMessage(reason) {

package/dist/report/build-report.js

@@ -1,10 +1,15 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 import { programsIn } from '../core/access/command-line.js';
-import { printedLines, protectedAccesses, readsContent } from '../core/access/protected-access.js';
+import { printedLines, printsOnly, protectedAccesses, readsContent, readsContentBesideNames } from '../core/access/protected-access.js';
+import { keyedLines } from '../core/access/protected-values.js';
 import { filesTracedIn, returnsOf, traceValues } from '../core/access/returns.js';
 import { valueUses } from '../core/access/uses.js';
 import { wordsBeforeCalls } from '../core/access/words-before.js';
+import { displayPath } from '../core/project-root.js';
 import { firstSentence } from '../shared/sentence.js';
 import { NAMES_PER_FILE } from './report-model.js';
+import { refusedByOthers } from './refusals.js';
 import { filesRead } from './flow-reads.js';
 /**
  * Identifiers are shortened in a report (§7.3). Both ends are kept: a `toolu_01…` prefix is shared by every
@@ -50,7 +55,7 @@ export function buildReport(model, policy, redactor, view = FULL_VIEW) {
     // F57: which patterns a person asked only to be told about, so a finding under one says the agent was let read it.
     const told = new Set(policy.protected.filter((entry) => entry.mode === 'tell').map((entry) => entry.pattern));
     const findings = accesses.map((access) => toFinding(access, model, redactor, view, told.has(access.pattern)));
-    const secretShapes = secretShapesIn(model, redactor, view);
+    const secretShapes = secretShapesIn(model, accesses, redactor, view);
     const delegations = model.delegations.map((delegation) => toDelegation(delegation, model, accesses, redactor, view));
     const gaps = gapsOf(model.gaps, returns);
     const attributed = new Set(model.delegations.map((delegation) => delegation.childAgentId));
@@ -183,7 +188,11 @@ function privateFilesOf(model, accesses, redactor) {
                     readInto(file, lines.join('\n'), redactor);
             }
         }
-        if (paths.length === 0 || content === undefined || event.outcome !== 'succeeded' || !readsContent(event))
+        if (paths.length === 0 || content === undefined || event.outcome !== 'succeeded')
+            continue;
+        // SWO1: a file's text beside a directory's names - its `KEY=value` lines are the file's, the names are not.
+        const besideNames = readsContentBesideNames(event);
+        if (!besideNames && !readsContent(event))
             continue;
         if (paths.length > 1) {
             for (const path of paths)
@@ -192,13 +201,32 @@ function privateFilesOf(model, accesses, redactor) {
         }
         const file = found.get(paths[0]);
         if (file !== undefined)
-            readInto(file, content, redactor);
+            readInto(file, besideNames ? keyedLines(content).join('\n') : content, redactor);
+    }
+    /*
+     * One file, however its path was written. `ls` prints it relative and the Read tool names it absolute, and both are
+     * shown the same: kept apart, the to-do list drew the same file twice (seen by the maintainer on 2026-10-02, a file
+     * listed by `ls` and then read). Told apart by where they are, never by how a view shows them: the shared view shows
+     * every file outside the project as the same words, and merging by those made several files one (found by review).
+     */
+    const shown = new Map();
+    for (const [path, file] of found) {
+        const where = displayPath(path, model.projectRoot);
+        const into = shown.get(where) ?? { path: redactor.path(path), keys: new Set(), names: new Map(), keyed: new Map(), mixed: false };
+        for (const key of file.keys)
+            into.keys.add(key);
+        for (const name of file.names)
+            into.names.set(name, name);
+        for (const line of file.keyed)
+            into.keyed.set(JSON.stringify([line.name, line.key]), line);
+        into.mixed ||= file.mixed;
+        shown.set(where, into);
     }
-    return [...found].map(([path, file]) => ({
-        path: redactor.path(path),
-        keys: file.keys.map((key) => redactor.term(key)),
-        names: file.names,
-        keyed: file.keyed.map((line) => ({ name: line.name, key: redactor.term(line.key) })),
+    return [...shown.values()].map((file) => ({
+        path: file.path,
+        keys: [...file.keys].map((key) => redactor.term(key)),
+        names: [...file.names.values()],
+        keyed: [...file.keyed.values()].map((line) => ({ name: line.name, key: redactor.term(line.key) })),
         ...(file.mixed ? { mixed: true } : {}),
     }));
 }
@@ -246,7 +274,14 @@ function everydayFilesOf(model, accesses, redactor) {
  * A recognised key format in what came back - `S-shape` of §5.4. It is reported even when the call touched no
  * protected path: a secret exported in a shell profile sits in no `.env` file, so path matching is blind to it.
  */
-function secretShapesIn(model, redactor, view) {
+function secretShapesIn(model, accesses, redactor, view) {
+    // The private files each call named and reached; its result is their text only where it printed them and nothing else.
+    const readPrivate = new Map();
+    for (const access of accesses) {
+        if (access.source !== 'input' || access.outcome !== 'succeeded')
+            continue;
+        readPrivate.set(access.eventId, (readPrivate.get(access.eventId) ?? new Set()).add(access.path));
+    }
     return model.events.flatMap((event) => {
         const content = event.result?.content;
         if (content === undefined)
@@ -262,6 +297,7 @@ function secretShapesIn(model, redactor, view) {
                 outcome: event.outcome,
                 classes: classes.map((name) => redactor.term(name)),
                 evidence: redactor.term(describeEvidence(event.result?.evidence ?? event.evidence, model, view)),
+                ...(printsOnly(event, readPrivate.get(event.id) ?? new Set()) ? { inPrivateFile: true } : {}),
             },
         ];
     });
@@ -314,6 +350,7 @@ function tallyOf(accesses, returns, uses, contentsSeen) {
         onlyThroughResult,
         namedByCall: files.size - onlyThroughResult,
         refusedAttempts: accesses.filter((access) => access.outcome === 'blocked').length,
+        ...othersAmong(accesses),
         unknownAttempts: accesses.filter((access) => access.outcome === 'unknown').length,
         valuesReturned: returns.filter((entry) => entry.strength === 'value').length,
         valuesWritten: returns.filter((entry) => entry.strength !== 'value' && entry.writtenFrom.length > 0).length,
@@ -324,6 +361,11 @@ function tallyOf(accesses, returns, uses, contentsSeen) {
         valueUses: uses.length,
     };
 }
+/** WS3: who refused the refused ones among these, where it was not a rule - absent where a rule refused them all. */
+function othersAmong(accesses) {
+    const byOthers = refusedByOthers(accesses.filter((access) => access.outcome === 'blocked'));
+    return byOthers === undefined ? {} : { refusedByOthers: byOthers };
+}
 /**
  * How many agents the contents of a protected file reached, by the same rule `session-view.ts` applies to draw
  * one: what a delegation returned, what an agent wrote of it, and every step of its flow that carried a value.
@@ -392,6 +434,7 @@ function graphOf(model, accesses, returns, uses, traced, redactor, view) {
             actions: model.events.filter((event) => event.agentId === agent.id).length,
             filesReached: files.length,
             refusedAttempts: own.filter((access) => access.outcome === 'blocked').length,
+            ...othersAmong(own),
             ...(worst === undefined ? {} : { topPath: redactor.path(worst) }),
             ...returnedOf(returns, agent.id),
             ...(uses.some((use) => use.agentId === agent.id && isWrittenOnward(use)) ? { wroteOnward: true } : {}),
@@ -490,17 +533,22 @@ function storiesOf(model, accesses, wordsBefore, traced, redactor, view) {
         const access = group[0];
         const agent = byAgent.get(access.agentId);
         const asked = askedOf.get(access.agentId);
+        const event = model.events.find((candidate) => candidate.id === access.eventId);
+        // S3: read is the page's word - the call printed the file's text, or a search printed its lines.
+        const read = access.source === 'input' && access.outcome === 'succeeded' && event !== undefined &&
+            (readsContent(event) || readsContentBesideNames(event) || (access.lines ?? 0) > 0);
         return {
             ...(agent === undefined ? {} : { agentIndex: model.agents.indexOf(agent) }),
             path: redactor.path(access.path),
             source: access.source,
             outcome: access.outcome,
+            ...(read ? { read: true } : {}),
             who: access.agentId === model.sessionId
                 ? redactor.term('the session itself')
                 : redactor.term(`${agentName(access.agentId, model, view)}${agent?.type === undefined ? '' : ` (${agent.type})`}`),
             ...(asked === undefined ? {} : { askedTo: redactor.scan(asked) }),
             did: redactor.term(didOf(access, model)),
-            toolKnown: model.events.find((event) => event.id === access.eventId)?.toolKnown ?? false,
+            toolKnown: event?.toolKnown ?? false,
             evidence: redactor.term(describeEvidence(access.evidence, model, view)),
             occurrences: group.length,
             ...linesTotal(group),

package/dist/report/check/actions-digest.js

@@ -1,4 +1,5 @@
 import { byString } from '../../shared/compare.js';
+import { sumRefusedByOthers } from '../refusals.js';
 /** Merges per-session actions by path and route. Most sessions first, then by name, so the order is stable. */
 export function digestOf(actions, context) {
     const rotate = new PathCounts();
@@ -30,6 +31,7 @@ export function digestOf(actions, context) {
             shapes.set(name, (shapes.get(name) ?? 0) + 1);
     }
     const first = actions[0];
+    const byOthers = sumRefusedByOthers(actions.map((session) => session.refusedByOthers));
     return {
         asked: context.asked,
         sessionsRead: actions.length,
@@ -43,6 +45,7 @@ export function digestOf(actions, context) {
         onlyInResults: onlyInResults.sorted(),
         unknown: unknown.sorted(),
         refusedAttempts: actions.reduce((sum, session) => sum + session.refusedAttempts, 0),
+        ...(byOthers === undefined ? {} : { refusedByOthers: byOthers }),
         secretShapes: [...shapes].map(([name, count]) => ({ name, count })).sort((a, b) => b.count - a.count || byString(a.name, b.name)),
         mentions: actions.reduce((sum, session) => sum + session.mentions, 0),
         ...(context.marks === undefined ? {} : { marks: context.marks }),

package/dist/report/check/check-lines.js

@@ -1,4 +1,5 @@
 import { NAMES_PER_FILE } from '../report-model.js';
+import { refusedByRule } from '../refusals.js';
 const ORDER = ['rotate', 'template', 'unknown', 'route', 'result'];
 /**
  * The labels that ask a person to do something: a key to change, a template to confirm, an outcome nobody recorded.
@@ -69,7 +70,7 @@ export function checkOf(sessions) {
         ...(keyed ? { keyed: true } : {}),
         ...(read === undefined ? {} : { read }),
     }));
-    return { rows, refusedAttempts: sessions.reduce((sum, { actions }) => sum + actions.refusedAttempts, 0) };
+    return { rows, refusedAttempts: sessions.reduce((sum, { actions }) => sum + refusedByRule(actions.refusedAttempts, actions.refusedByOthers), 0) };
 }
 /** Two sessions' reads of one file: every key format and line either saw, in the order first seen. */
 function mergeReads(a, b) {

package/dist/report/check/render/text-digest-renderer.js

@@ -1,6 +1,9 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 import { paint } from '../../../shared/colour.js';
 import { table } from '../../../shared/text-table.js';
 import { needsAction } from '../actions-digest.js';
+import { refusedByRule } from '../../refusals.js';
 const INDENT = 2;
 /** How many files the brief view names before it says how many more there are (R15a). */
 const BRIEF_ROWS = 5;
@@ -76,7 +79,7 @@ function brief(digest) {
                 ? `Nothing left to act on: ${read(digest)}${under(digest)}.`
                 : `Nothing to act on: ${read(digest)}${under(digest)}, and no protected file was reached.`,
             ...unreadableLines(digest),
-            ...(digest.refusedAttempts === 0 ? [] : [`Your rules held: ${plural(digest.refusedAttempts, 'attempt was', 'attempts were')} refused.`]),
+            ...stoppedSentences(digest),
             ...markLines(digest),
         ];
     }
@@ -89,9 +92,8 @@ function brief(digest) {
         '',
         ...table(shown.map((row) => [`${LABELS[row.label].padEnd(width)}  ${shorten(row.path).padEnd(pathWidth)}`, `${row.says}, ${inSessions(row.sessions)}`]), INDENT),
         ...(rows.length > shown.length ? [`${' '.repeat(INDENT)}and ${rows.length - shown.length} more`] : []),
-        ...(digest.refusedAttempts === 0
-            ? []
-            : [`${' '.repeat(INDENT)}your rules held: ${plural(digest.refusedAttempts, 'attempt was', 'attempts were')} refused`]),
+        // Under the rows, as their footnote: lower case and no full stop, as the lines beside them are.
+        ...stoppedSentences(digest).map((sentence) => `${' '.repeat(INDENT)}${sentence.charAt(0).toLowerCase()}${sentence.slice(1, -1)}`),
         ...(digest.mentions === 0
             ? []
             : [`${' '.repeat(INDENT)}${plural(digest.mentions, 'path was', 'paths were')} named in text a call carried, which opens no file; not counted`]),
@@ -186,7 +188,7 @@ function counts(digest) {
     }
     // One sentence per line: the counts, what the rules held, and what is already dealt with are three answers, and
     // run together they were one line long enough to wrap twice in a terminal nobody had made wide for it.
-    const held = digest.refusedAttempts === 0 ? [] : [`Your rules held: ${plural(digest.refusedAttempts, 'attempt was', 'attempts were')} refused.`];
+    const held = stoppedSentences(digest);
     const done = doneLine(digest);
     if (!needsAction(digest)) {
         return [`Nothing to act on in the ${plural(digest.sessionsRead, 'session', 'sessions')} read.`, ...held, ...done, ...unreadable];
@@ -224,11 +226,30 @@ function under(digest) {
     return digest.policy === undefined ? '' : `, read under ${digest.policy}`;
 }
 function refusedLines(digest) {
-    if (digest.refusedAttempts === 0)
+    const [rules, ...others] = stoppedSentences(digest);
+    if (rules === undefined)
         return [];
+    // What follows is about a rule's refusal alone, so it stays with the rules' line and is not said of the others (WS4).
+    return rules.startsWith(RULES_HELD)
+        ? [`${rules} A refused Read raises no hook event, so only the`, 'transcripts show these.', ...others]
+        : [rules, ...others];
+}
+const RULES_HELD = 'Your rules held:';
+const AUTO_MODE_STOPPED = 'Auto mode stopped';
+const YOU_TURNED_DOWN = 'You turned down';
+/**
+ * What was stopped, and by whom (`specs/2026-10-01-who-stopped-it.md` WS4): a rule's refusals are the rules having held,
+ * and an attempt Claude Code's auto mode or the person stopped is said as theirs - crediting a rule with it would tell a
+ * person their rules cover a route they do not. One sentence each, the rules' first; a count of zero says nothing.
+ */
+function stoppedSentences(digest) {
+    const byRule = refusedByRule(digest.refusedAttempts, digest.refusedByOthers);
+    const reviewer = digest.refusedByOthers?.reviewer ?? 0;
+    const person = digest.refusedByOthers?.person ?? 0;
     return [
-        `Your rules held: ${plural(digest.refusedAttempts, 'attempt was', 'attempts were')} refused. A refused Read raises no hook event, so only the`,
-        'transcripts show these.',
+        ...(byRule === 0 ? [] : [`${RULES_HELD} ${plural(byRule, 'attempt was', 'attempts were')} refused.`]),
+        ...(reviewer === 0 ? [] : [`${AUTO_MODE_STOPPED} ${plural(reviewer, 'attempt', 'attempts')}.`]),
+        ...(person === 0 ? [] : [`${YOU_TURNED_DOWN} ${plural(person, 'attempt', 'attempts')}.`]),
     ];
 }
 function section(shown, heading, explanation, rows) {
@@ -301,7 +322,8 @@ function colourise(lines) {
         // A range that is clear, and rules that refused something, are the two things that went well.
         if (/^Nothing (?:left )?to act on/.test(line))
             return paint(line, 'green');
-        for (const prefix of ['Your rules held:']) {
+        // What stopped an attempt went well, whoever stopped it.
+        for (const prefix of [RULES_HELD, AUTO_MODE_STOPPED, YOU_TURNED_DOWN]) {
             if (line.startsWith(prefix))
                 return `${paint(prefix, 'green')}${line.slice(prefix.length)}`;
         }

package/dist/report/check/session-actions.js

@@ -1,5 +1,4 @@
 import { filesRead } from '../flow-reads.js';
-import { RULE_NAMES } from '../rule-names.js';
 /**
  * Whether a file read holds keys, as far as what was read says: a recognised key format, or a read shared with another
  * protected file, whose keys may be this one's (`PrivateFile.mixed`). The to-do list and the marks decide by this alone.
@@ -9,8 +8,6 @@ export function holdsKeys(file) {
 }
 /** Names a file kept as an example rather than as configuration. A convention, matched on the name and nothing else. */
 const TEMPLATE = /\.(example|sample|template|dist)$/;
-/** The patterns of the built-in rules, every one of them for passwords and keys (F45). */
-const KEY_RULES = new Set(RULE_NAMES.flatMap((group) => group.patterns));
 /** Whether a path is named as a template (R12c): the one test the check and the report page share. */
 export function isTemplate(path) {
     return TEMPLATE.test(path);
@@ -67,9 +64,9 @@ export function actionsOf(report) {
     const readOf = new Map(report.privateFiles.map((file) => [file.path, readOfFile(file)]));
     return {
         policy: report.scope.policy.origin,
-        // F57: a told file's contents were read because the person let them be; only keys in it still need changing - a key
-        // of a known format, or any file a built-in rule for passwords and keys covers (F45: that rule is itself the fact).
-        rotate: [...rotate].filter((path) => !toldPaths.has(path) || keyed.has(path) || KEY_RULES.has(patternOf.get(path))).sort().map((path) => {
+        // F57a, amended 2026-10-02 by the maintainer: a told file's contents were read because the person let them be, keys
+        // included - they chose Track for it - so nothing about it is to fix. It stays on `told`, said and never asked for.
+        rotate: [...rotate].filter((path) => !toldPaths.has(path)).sort().map((path) => {
             const read = readOf.get(path);
             return { path, template: TEMPLATE.test(path), ...(keyed.has(path) ? { keyed: true } : {}), ...(read === undefined ? {} : { read }) };
         }),
@@ -78,6 +75,7 @@ export function actionsOf(report) {
         onlyInResults: [...onlyInResults].sort(),
         unknown: [...new Set(reaching.filter((story) => story.outcome === 'unknown').map((story) => story.path))].sort(),
         refusedAttempts: report.tally.refusedAttempts,
+        ...(report.tally.refusedByOthers === undefined ? {} : { refusedByOthers: report.tally.refusedByOthers }),
         secretShapes: report.secretShapes.flatMap((finding) => finding.classes),
         mentions: mentions.size,
     };

package/dist/report/check/session-check.js

@@ -1,9 +1,13 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
+import { noStoreAnywhere } from '../../core/session-catalogue.js';
 import { splitBySince } from '../../core/session-filter.js';
 import { choosePolicy, policyRefusal } from '../choose-policy.js';
 import { digestOf } from './actions-digest.js';
 import { checkOf } from './check-lines.js';
 import { noteProblem, recordMark, recordUnmark } from './mark-request.js';
 import { actionsAfterMarks, marksInRange, standingMarks } from './marks.js';
+import { nothingSavedHere } from '../nothing-saved-here.js';
 /** Each report is run for its actions; the text it also renders is discarded, so this only has to be a valid width. */
 const DISCARDED_WIDTH = 100;
 /**
@@ -56,6 +60,10 @@ export class SessionCheck {
         if ('errors' in chosen)
             return { answer: { outcome: 'policy-refused', output: policyRefusal(chosen.errors) } };
         const listing = await catalogue.list(workingDirectory);
+        if (!listing.found && noStoreAnywhere(listing)) {
+            const ways = 'use Claude Code here, then run agentwhy check again - or run agentwhy init now, to be protected before there is history to check.';
+            return { answer: { outcome: 'no-sessions', output: nothingSavedHere('Claude Code', listing.directory, ways) } };
+        }
         if (!listing.found || listing.sessions.length === 0) {
             return {
                 answer: {

package/dist/report/choose-policy.js

@@ -1,3 +1,5 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 import { policyFromDenyRules, readDenyRules } from '../adapter/claude-code/policy/deny-rules.js';
 import { parsePolicy } from '../core/policy/parse-policy.js';
 import { readTellLists, tellPatterns } from './private-files/tell-lists.js';
@@ -40,9 +42,13 @@ function withTold(policy, told) {
     const builtIn = policy.origin.kind === 'default';
     const kept = policy.protected.filter((entry) => !(builtIn && told.includes(entry.pattern)));
     const blocked = new Set(kept.map((entry) => entry.pattern));
+    // The told patterns answer first: a file tracked by its name (`**/demo.env`) under a broader blocking pattern
+    // (`**/*.env`) is told however its path was written. Appended last, the Read tool's absolute path was answered by
+    // the broad pattern and called a key to change, while the same file read by its bare name was told (found by the
+    // maintainer, 2026-10-02). A pattern on both lists is still blocked - it is never given a told entry at all.
     return {
         ...policy,
-        protected: [...kept, ...told.filter((pattern) => !blocked.has(pattern)).map((pattern) => ({ pattern, mode: 'tell' }))],
+        protected: [...told.filter((pattern) => !blocked.has(pattern)).map((pattern) => ({ pattern, mode: 'tell' })), ...kept],
     };
 }
 /** The words a refused policy is reported in, the same for every command that reads one. */

package/dist/report/nothing-saved-here.js

@@ -0,0 +1,16 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * What `start`, `sessions` and `check` say where no AI's store of conversations is there at all
+ * (`.ai/specs/2026-09-16-worth-running-every-day.md` R28, amended 2026-10-01). Two things look the same from here: a
+ * computer the AI has not been used on yet, and an AI app's sandbox or virtual machine, measured twice that day, where
+ * "not used yet" was false. Each is said with its own way forward - R28's for the first, `init` among it, and a terminal on
+ * the person's own computer for the second - since nothing a run sees tells them apart.
+ */
+export function nothingSavedHere(agents, where, notUsedYet) {
+    return `No ${agents} conversations are saved where agentwhy looked: ${where}\n` +
+        `Either ${agents} ${agents.includes(' or ') ? 'have' : 'has'} not been used on this computer yet, or agentwhy is running somewhere they are not ` +
+        `saved: an AI app's sandbox or a virtual machine runs commands apart from your computer.\n` +
+        `Not used yet: ${notUsedYet}\n` +
+        `Running elsewhere: run agentwhy in a terminal on your own computer, in your project's folder.\n`;
+}

package/dist/report/private-files/tell-lists.js

@@ -1,3 +1,5 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 import { dirname, join } from 'node:path';
 import { projectDirectoryName } from '../../adapter/claude-code/contract/projects.js';
 import { SETTINGS_FILES } from '../../adapter/claude-code/contract/settings.js';

package/dist/report/project-rules.js

@@ -1,3 +1,5 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 import { join } from 'node:path';
 import { SETTINGS_FILES } from '../adapter/claude-code/contract/settings.js';
 import { readDenyRules } from '../adapter/claude-code/policy/deny-rules.js';

package/dist/report/refusals.js

@@ -0,0 +1,15 @@
+/** Counted from what refused each attempt. An attempt with no source on record is a rule's: only a rule leaves none. */
+export function refusedByOthers(refused) {
+    return others(refused.filter((attempt) => attempt.refusedBy === 'reviewer').length, refused.filter((attempt) => attempt.refusedBy === 'person').length);
+}
+/** The same, over several counts: attempts add up, so their sources do. */
+export function sumRefusedByOthers(counts) {
+    return others(counts.reduce((sum, count) => sum + (count?.reviewer ?? 0), 0), counts.reduce((sum, count) => sum + (count?.person ?? 0), 0));
+}
+/** How many of a total a rule refused: what "Your rules held" may count (WS4). */
+export function refusedByRule(total, byOthers) {
+    return Math.max(0, total - (byOthers?.reviewer ?? 0) - (byOthers?.person ?? 0));
+}
+function others(reviewer, person) {
+    return reviewer === 0 && person === 0 ? undefined : { reviewer, person };
+}

package/dist/report/render/home-relative.js

@@ -1,3 +1,5 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 import { isAbsolute, relative, resolve, sep } from 'node:path';
 /**
  * Where a folder is, as a person reads it (`.ai/specs/2026-09-27-which-project.md` V1): `~/Projects/shop` under the home

package/dist/report/render/html-head.js

@@ -1,3 +1,5 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 /**
  * The policy every page this tool writes is served under - by nothing, since a page is opened as a file. It says
  * that the page may run its own inline script and style and may reach **nowhere**: no fetch, no image but a `data:` one, no form

package/dist/report/render/html-report-styles.js

@@ -1,3 +1,5 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 /**
  * The session report, wearing the sessions observatory's clothes: a fixed sidebar, a topbar that says where you
  * are, the verdict as a heading rather than a banner, and one workbench of two panels — the two views of the

package/dist/report/render/html-sidebar.js

@@ -1,3 +1,5 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 import { labelAttributes } from './report-copy.js';
 import { BRAND_MARK } from './ui/brand-mark.js';
 /**

package/dist/report/render/path-tail.js

@@ -1,3 +1,5 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 /**
  * How many of a path's last segments it takes to tell it from every other path named beside it
  * (`specs/2026-09-14-path-display-and-share.md` R5): two files a page names must never read alike, and a name alone reads

package/dist/report/render/report-copy.js

@@ -1,3 +1,5 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 import { APP_WORDS } from './ui/words/app-words.js';
 import { CONVERSATIONS_WORDS } from './ui/words/conversations-words.js';
 import { MONTH_WORDS } from './ui/words/month-words.js';

package/dist/report/render/report-page/advanced-view.js

@@ -1,3 +1,5 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 import { escapeHtml as e } from '../html-report-components.js';
 import { inLanguages } from '../report-copy.js';
 import { avatarGroup } from '../ui/avatar.js';

package/dist/report/render/report-page/files-view.js

@@ -1,3 +1,5 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 import { escapeHtml as e } from '../html-report-components.js';
 import { inLanguages, labelAttributes, LANGS, translator } from '../report-copy.js';
 import { closeButton, pill, textButton } from '../ui/button.js';

package/dist/report/render/report-page/files.js

@@ -1,3 +1,5 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 import { matchesGlob } from '../../../core/policy/glob.js';
 import { helperViews } from './helpers.js';
 import { nameOf, ruleKey } from './item-names.js';

package/dist/report/render/report-page/fix-wizard-script.js

@@ -1,3 +1,5 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 /**
  * The Fix it wizard's steps (the report page spec P18-P25): one step shown at a time; on the first, "Skip for now", which
  * moves to the next file and writes nothing (F52, O13), beside the main button "I did it", which goes on once every row

package/dist/report/render/report-page/helpers-view.js

@@ -1,3 +1,5 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 import { escapeHtml as e } from '../html-report-components.js';
 import { inLanguages, labelAttributes } from '../report-copy.js';
 import { avatar } from '../ui/avatar.js';

package/dist/report/render/report-page/item-names.js

@@ -1,3 +1,5 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 import { escapeHtml as e } from '../html-report-components.js';
 import { distinctDepth } from '../path-tail.js';
 const LOCALES = { en: 'en-US', pl: 'pl-PL', de: 'de-DE' };

package/dist/report/render/report-page/protect-patterns.js

@@ -1,3 +1,5 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 import { insideProject } from '../../../core/project-root.js';
 import { nameOf } from './item-names.js';
 /**

package/dist/report/render/report-page/report-views.js

@@ -1,3 +1,5 @@
+// Copyright 2026 Nessprim Karol Kozer
+// SPDX-License-Identifier: Apache-2.0
 /**
  * The report page's views (the report page spec P2, P45): one section per sidebar item. With a script the one the
  * address names is shown - the first where it names none - and its sidebar item is the active one; with none, every

package/dist/report/render/report-page/to-do-view.js

@@ -103,7 +103,8 @@ function gapBanner(report) {
 }
 function nothingView(report, gaps, rows, context, names) {
     const say = (key, vars = {}) => inLanguages((t) => t(key, vars));
-    const shapes = [...new Set(report.secretShapes.flatMap((finding) => finding.classes.map(String)))];
+    // P59 is a key in no private file. One in a private file's text is that file's (SW7): a tracked file says so below.
+    const shapes = [...new Set(report.secretShapes.filter((finding) => finding.inPrivateFile !== true).flatMap((finding) => finding.classes.map(String)))];
     const back = context.back ? '<div class="rp-back">' + pill({ label: say('rp.nothing.back'), tone: 'light', size: 'lg', href: 'index.html' }) + '</div>' : '';
     // P59: a key's shape in a result is never a clean screen - but it is not a to-do item either, since no protected file
     // is known to hold it. The answer says what to do and where the record shows it, and the summary says what else the AI
@@ -162,7 +163,7 @@ function heroGo(label) {
 }
 /**
  * The private files the AI read that ask for nothing (F57a): on a screen with nothing to fix, every private file read is
- * one the person chose Tell me for and that held no key - the to-do list keeps every other read.
+ * one the person chose Tell me for - keys or not, since 2026-10-02 (SW7) - and the to-do list keeps every other read.
  */
 function allowedReads(rows) {
     return rows.filter((row) => row.private && row.access === 'read' && row.item === undefined).map((row) => row.path);