@event4u/agent-config 16.1.0 → 16.3.0

package/src/scripts/_lib/rule_law_section.ts

@@ -0,0 +1,147 @@
+/**
+ * One spelling of "a rule's law section" — the unit three gates and one
+ * projector all price.
+ *
+ * A **law section** is a heading whose title matches `\biron\s+laws?\b` plus
+ * everything under it up to the next heading of the same or a shallower depth.
+ * A rule may carry several (`direct-answers` has three, `no-cheap-questions`
+ * six); the rule's law is all of them, joined by a blank line, because each one
+ * states an obligation and a stub carrying only the first would ship a rule
+ * whose other laws silently vanished.
+ *
+ * WHY A SHARED MODULE RATHER THAN A REGEX PER CALLER. The projector
+ * (`project_thin_rules.ts`) byte-copies this text into a stub and digests it;
+ * the lint (`lint_rule_law_section.ts`) holds it under a ceiling. If those two
+ * disagreed about where a section ends, the lint would certify a length the
+ * projection does not carry — the exact drift `THIN_ENTRY_MARKER`'s own comment
+ * argues against one file over.
+ *
+ * The heading regex is deliberately the SAME one `check_iron_law_prominence.ts`
+ * uses, so "has a law section" here and "is an Iron Law heading" there cannot
+ * diverge. That gate owns prominence (H2, near the top); this module owns
+ * extent and size.
+ *
+ * WHAT THIS DOES NOT CLAIM. Not that the extracted text IS the rule's obligation. A rule can state its
+ * law in bold prose or a bare fence under no heading at all — several of the 35
+ * routed rules without a heading match do exactly that. A heading match is a
+ * STRUCTURAL property, checkable; "this sentence is the obligation" is not, and
+ * `report_obligation_carriers` plus the `# obligation: line N` marker is where
+ * that question already lives.
+ */
+import * as fs from 'node:fs';
+
+/** Same literal as `check_iron_law_prominence.ts` — one definition, two readers. */
+export const IRON_LAW_RE = /\biron\s+laws?\b/i;
+
+const HEADING_RE = /^(#{1,6})\s+(.+?)\s*$/;
+const FENCE_RE = /^\s*```/;
+
+export interface LawSection {
+    /** Heading title, verbatim. */
+    title: string;
+    /** Heading depth (1–6). */
+    depth: number;
+    /** 1-based line of the heading within the body. */
+    line: number;
+    /** Heading line plus its section, trimmed. */
+    text: string;
+}
+
+/** Return `[frontmatter_including_fences, body]`. Empty frontmatter if none. */
+export function splitFrontmatter(text: string): [string, string] {
+    if (text.startsWith('---\n')) {
+        const end = text.indexOf('\n---\n', 4);
+        if (end !== -1) {
+            return [text.slice(0, end + 5), text.slice(end + 5)];
+        }
+    }
+    return ['', text];
+}
+
+/**
+ * The body a runtime delivery carries: frontmatter removed, HTML comments
+ * removed, trimmed.
+ *
+ * Comments are stripped because they are authoring scaffolding
+ * (`<!-- risk-review: … -->`, `<!-- harvest:… -->`, `ref-ignore` markers) that
+ * no host renders to a model, so charging a rule for them would price the wrong
+ * thing. Frontmatter is excluded for the reason `check_rule_stub_ceiling` gives
+ * for the same exclusion: it is the routing surface, and a rule that gains a
+ * trigger must not trip a ceiling whose message tells the author to move prose.
+ */
+export function ruleBody(text: string): string {
+    const [, body] = splitFrontmatter(text);
+    return body.replace(/<!--[\s\S]*?-->/g, '').trim();
+}
+
+/** Every law section in a rule body, in document order. */
+export function lawSections(body: string): LawSection[] {
+    const lines = body.split('\n');
+    let inFence = false;
+    const headings: Array<{ i: number; depth: number; title: string }> = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const raw = lines[i] as string;
+        if (FENCE_RE.test(raw)) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence) continue;
+        const m = HEADING_RE.exec(raw);
+        if (m) headings.push({ i, depth: (m[1] as string).length, title: (m[2] as string).trim() });
+    }
+    const out: LawSection[] = [];
+    for (let k = 0; k < headings.length; k += 1) {
+        const h = headings[k] as { i: number; depth: number; title: string };
+        if (!IRON_LAW_RE.test(h.title)) continue;
+        let end = lines.length;
+        for (let j = k + 1; j < headings.length; j += 1) {
+            const n = headings[j] as { i: number; depth: number; title: string };
+            if (n.depth <= h.depth) {
+                end = n.i;
+                break;
+            }
+        }
+        out.push({
+            title: h.title,
+            depth: h.depth,
+            line: h.i + 1,
+            text: lines.slice(h.i, end).join('\n').trim(),
+        });
+    }
+    return out;
+}
+
+/**
+ * The rule's law, as one byte string — all sections joined by a blank line.
+ * `null` when the rule has none, which is a different answer from `''`.
+ */
+export function lawText(body: string): string | null {
+    const sections = lawSections(body);
+    if (sections.length === 0) return null;
+    return sections.map((s) => s.text).join('\n\n');
+}
+
+export interface RuleLawMeasure {
+    id: string;
+    /** Characters of the law text, 0 when there is none. */
+    lawChars: number;
+    /** Number of law sections found. */
+    sections: number;
+    /** Characters of the comment-stripped body. */
+    bodyChars: number;
+    /** The law text itself, `null` when absent. */
+    law: string | null;
+}
+
+/** Measure one rule file. */
+export function measureRuleFile(id: string, filePath: string): RuleLawMeasure {
+    const body = ruleBody(fs.readFileSync(filePath, 'utf-8'));
+    const law = lawText(body);
+    return {
+        id,
+        lawChars: law === null ? 0 : law.length,
+        sections: lawSections(body).length,
+        bodyChars: body.length,
+        law,
+    };
+}

package/src/scripts/_lib/rule_layer_overlap.ts

@@ -25,6 +25,7 @@
  */
 
 import * as fs from 'node:fs';
+import * as os from 'node:os';
 import * as path from 'node:path';
 
 /**
@@ -140,6 +141,63 @@ export function compareLayers(
     };
 }
 
+/**
+ * The two directories Claude Code loads rules from, user layer first.
+ *
+ * ONE SOURCE OF TRUTH FOR SCOPE (`road-to-a-rule-carrier-that-works-outside-the-repo`
+ * step 1.3). Two readers need this pair and both used to spell it out inline:
+ * the installer's overlap gate, and — once the carrier started resolving bodies
+ * from the package rather than from the workspace — the delivery scope itself.
+ * A carrier scoping on one list while the installer gates on another would
+ * deliver a rule the install never wrote, which is the state step 1.3 exists to
+ * end.
+ *
+ * It is a UNION and not a precedence chain. The host loads both with no dedup —
+ * that is the whole reason this module exists — so a rule present in either
+ * layer is loaded, and "what the install carries" is the union of the two.
+ *
+ * `os.homedir()` rather than a settings key: the installer resolves the user
+ * layer the same way, and a second spelling of "where is home" is a second
+ * thing to disagree about.
+ */
+export function hostRuleLayerDirs(projectRoot: string): [string, string] {
+    return [
+        path.join(os.homedir(), '.claude', 'rules'),
+        path.join(projectRoot, '.claude', 'rules'),
+    ];
+}
+
+/**
+ * Rule ids present in either host rule layer, or `null` when NEITHER directory
+ * exists.
+ *
+ * `null` IS A DIFFERENT ANSWER FROM AN EMPTY SET, and the difference is the
+ * contract. An empty set means the install wrote a rule layer and it carries
+ * nothing, so nothing is in scope. `null` means no rule layer exists to declare
+ * a scope at all: a maintainer checkout, or a host this install writes no rules
+ * directory for. Scoping to the empty set there would re-create exactly the
+ * silence step 1.1 repaired, so the caller applies no filter instead.
+ *
+ * Names only, never bodies. This runs on the `user_prompt_submit` hot path, and
+ * {@link readRuleLayer} beside it reads every file's contents because ITS
+ * caller compares them. A scope check never needs a byte of any of them.
+ */
+export function hostRuleLayerIds(projectRoot: string): Set<string> | null {
+    const ids = new Set<string>();
+    let found = false;
+    for (const dir of hostRuleLayerDirs(projectRoot)) {
+        let names: string[];
+        try {
+            names = fs.readdirSync(dir);
+        } catch {
+            continue;
+        }
+        found = true;
+        for (const n of names) if (n.endsWith('.md')) ids.add(n.slice(0, -3));
+    }
+    return found ? ids : null;
+}
+
 /**
  * Read every `.md` in `dir` into a {@link RuleLayer}, or `null` when the
  * directory does not exist.

package/src/scripts/_lib/shell_write_shapes.ts

@@ -0,0 +1,108 @@
+/**
+ * The shell shapes that mean "this path is being WRITTEN", shared by the
+ * PreToolUse guards that refuse a write to a governed file.
+ *
+ * WHY IT IS SHARED. `block_kernel_rule_writes.ts` grew this parser after the
+ * S0.2 spike measured a real gap: a guard keyed on the TOOL NAME let
+ * `Bash sed -i … src/rules/commit-policy.md` reach the outcome the Write
+ * branch refuses, and a two-step `Write` → `Bash mv` sequence did the same with
+ * every individual step allowed. `block_plumbing_writes.ts`
+ * (road-to-a-kernel-that-guards-its-plumbing 1.2) refuses a different file set
+ * against the same shapes. Two copies of a shell-shape parser is two places a
+ * verb can be added to one and forgotten in the other, and the guard that
+ * silently stopped recognising `tee` would look exactly like the guard that
+ * never had to.
+ *
+ * DELIBERATELY NARROW (council 2026-08-02 cut, option ii, recorded on the
+ * kernel guard and inherited here unchanged): only redirection into the path,
+ * an in-place `sed`, a `tee`/`truncate`/`rm`/`shred` naming it, or a
+ * `mv`/`cp`/`install`/`rsync` whose DESTINATION it is. Reads stay allowed —
+ * `cat`, `grep`, `head`, `diff`, `git show` carry none of these shapes — and no
+ * attempt is made to understand arbitrary shell. Recognising every conceivable
+ * write verb would make this a shell sandbox, which is the failure mode the
+ * council named.
+ *
+ * KNOWN-OPEN, stated rather than implied: a write routed through an
+ * interpreter (`python -c`, a heredoc fed to `sh`) carries none of these
+ * shapes and is not detected. This is a guard, not write mediation.
+ */
+import * as path from 'node:path';
+
+/** In-place mutators that name their target as a plain argument. */
+const MUTATOR_VERBS: ReadonlySet<string> = new Set(['sed', 'tee', 'truncate', 'rm', 'shred']);
+
+/** Verbs whose LAST positional argument is the destination. */
+const DEST_LAST_VERBS: ReadonlySet<string> = new Set(['mv', 'cp', 'install', 'rsync']);
+
+/**
+ * The first governed target a command WRITES, or `null`.
+ *
+ * @param command the raw shell string off the tool envelope
+ * @param match   classifies one token: a non-null return names the governed
+ *                target that token resolves to, and is what this returns
+ */
+export function shellWriteTarget<T>(command: string, match: (token: string) => T | null): T | null {
+    const tokens = command.split(/\s+/).filter((t) => t.length > 0);
+    const stripped = tokens.map((t) => t.replace(/^['"]|['"]$/g, ''));
+
+    // Cheap reject first: no governed path in the string at all.
+    if (!stripped.some((t) => match(t) !== null)) {
+        return null;
+    }
+
+    // 1. Redirection into the path: `> p`, `>> p`, `>p`, `>>p`.
+    for (let i = 0; i < stripped.length; i += 1) {
+        const tok = stripped[i] as string;
+        const inline = /^>{1,2}(.+)$/.exec(tok);
+        if (inline) {
+            const r = match(inline[1] as string);
+            if (r !== null) {
+                return r;
+            }
+        }
+        if (tok === '>' || tok === '>>') {
+            const next = stripped[i + 1];
+            if (typeof next === 'string') {
+                const r = match(next);
+                if (r !== null) {
+                    return r;
+                }
+            }
+        }
+    }
+
+    // 2. A mutator verb anywhere in the pipeline, with the path as an argument.
+    //    `sed` only counts in its in-place form — `sed 's/x/y/' file` prints.
+    const verbs = new Set<string>();
+    let prevWasSeparator = true;
+    for (const tok of stripped) {
+        if (['&&', '||', ';', '|'].includes(tok)) {
+            prevWasSeparator = true;
+            continue;
+        }
+        if (prevWasSeparator && !tok.startsWith('-')) {
+            verbs.add(path.basename(tok));
+            prevWasSeparator = false;
+        }
+    }
+    const sedInPlace = verbs.has('sed') && stripped.some((t) => /^-i/.test(t));
+    for (const verb of verbs) {
+        if (verb === 'sed' && !sedInPlace) {
+            continue;
+        }
+        if (MUTATOR_VERBS.has(verb)) {
+            const hit = stripped.map(match).find((r) => r !== null);
+            if (hit !== undefined && hit !== null) {
+                return hit;
+            }
+        }
+        if (DEST_LAST_VERBS.has(verb)) {
+            const last = stripped[stripped.length - 1] as string;
+            const r = match(last);
+            if (r !== null) {
+                return r;
+            }
+        }
+    }
+    return null;
+}

package/src/scripts/_lib/skill_origin.ts

@@ -0,0 +1,254 @@
+/**
+ * Who put a ranked skill on disk, and whether its body has been looked at.
+ *
+ * SPLIT OUT OF `neighbour_census.ts` FOR ONE CONCRETE REASON. The ranker
+ * (`skill_tools/score_skill_relevance`) needs these primitives, and the ranker
+ * runs inside the shared hook bundle on `user_prompt_submit`. The census module
+ * reaches the host-hook merger, the secret detector and the install-ownership
+ * reader; every byte of that would be inlined into one bundle that every concern
+ * loads on every dispatch, under a ceiling `check_hook_bundle_composition` holds.
+ * So the primitives live here, importing only the manifest reader, and the census
+ * re-exports them — one definition, two call sites, no second module graph.
+ *
+ * ORIGIN IS READ FROM A CLAIM RECORD, NEVER INFERRED FROM A ROOT. The temptation
+ * is to call `~/.claude/skills` foreign and the workspace ours. That is wrong in
+ * both directions: `agent-config install` writes this package's own skills into
+ * the host-global root, and a consumer's hand-written skills sit in the project
+ * root. The one artifact that records what this package actually wrote is the
+ * installed-tools manifest, so the manifest is the authority and the root is only
+ * a tie-break between the two NON-package labels.
+ */
+import { createHash } from 'node:crypto';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import { parse as parseYaml } from 'yaml';
+
+import { manifest_path } from './installed_tools.js';
+
+/**
+ * Where a RANKED skill came from — a question about AUTHORSHIP.
+ *
+ * Deliberately not the census's `origin` id segment, which is WHERE a file was
+ * found (`project`, `user`, `cursor`, …). Location does not answer authorship in
+ * either direction, which is the whole reason this type exists beside that one.
+ *
+ * `home` is spelled `home` rather than the census's `user` because this value is
+ * printed on a ROUTE LINE beside a skill name, where it has to read as a place a
+ * reader can go and look.
+ */
+export type SkillOrigin = 'package' | 'project' | 'home';
+
+/** One `compat` label per neighbour skill. Order decided in {@link classifyCompat}. */
+export type Compat = 'shadowed' | 'overlapping' | 'unscanned' | 'unclassified';
+
+/** The authored source tree, relative to a maintainer checkout's root. */
+export const AUTHORED_SKILL_ROOT = path.join('src', 'skills');
+
+/** Where the scan verdicts the ranker reads are written, relative to the root. */
+export const SCAN_CACHE_RELATIVE = path.join('agents', 'reports', 'neighbour-scan.json');
+
+/** Default scan-cache path for a project root. */
+export function scanCachePath(projectRoot: string): string {
+    return path.join(projectRoot, SCAN_CACHE_RELATIVE);
+}
+
+/**
+ * What a route line prints: bare for ours, `origin:name` for a neighbour.
+ *
+ * One function, so the ranker, the census and every report agree on the
+ * spelling. Two spellings of one name is how a collision stops being visible,
+ * which is the defect this whole step exists to close.
+ */
+export function qualifiedSkillName(name: string, origin: SkillOrigin): string {
+    return origin === 'package' ? name : `${origin}:${name}`;
+}
+
+/** Split a qualified name back apart. A bare name resolves to `package`. */
+export function splitQualifiedName(qualified: string): { origin: SkillOrigin; name: string } {
+    const m = /^(project|home):([\s\S]*)$/.exec(qualified);
+    if (m) return { origin: m[1] as SkillOrigin, name: m[2] as string };
+    return { origin: 'package', name: qualified };
+}
+
+/**
+ * Every absolute path this package's installed-tools manifest claims, or `null`
+ * when there is no manifest to claim anything.
+ *
+ * `null` and an empty set are different answers and callers must keep them
+ * apart. An empty set means the manifest was read and claims nothing; `null`
+ * means nothing recorded a claim at all, which is a tree that has never run an
+ * install — this repository, for one.
+ *
+ * WHY THIS PARSES THE MANIFEST ITSELF, which is a thing to justify rather than
+ * do quietly. Three readers of this file already exist and none answers this
+ * question at a cost this path can pay. `installed_tools.read_manifest` drops
+ * the nested `tools[].files[]` rows by design — its own header says so, and
+ * those rows are the entire input here. `install_drift.collect_drift` and
+ * `recordedOwnership.readRecordedHashes` both parse the YAML directly FOR THAT
+ * REASON, so parsing it directly is the established answer rather than a new
+ * idea; what is new is the fourth question — the PATHS only, with no sha, no
+ * tool grouping and no hash map. `readRecordedHashes` would have answered it
+ * and was measured costing 1,706 bytes of the shared hook bundle, which is the
+ * budget this whole module was split out to protect. The `~` expansion below is
+ * the same one all three use.
+ */
+export function packageClaimedPaths(projectRoot: string): ReadonlySet<string> | null {
+    const manifest = manifest_path(projectRoot);
+    let doc: unknown;
+    try {
+        doc = parseYaml(fs.readFileSync(manifest, 'utf-8'), { version: '1.1' });
+    } catch {
+        // Unreadable and absent are the same answer: nothing recorded a claim.
+        return null;
+    }
+    if (doc === null || typeof doc !== 'object' || Array.isArray(doc)) return null;
+    const tools = (doc as Record<string, unknown>)['tools'];
+    const out = new Set<string>();
+    if (!Array.isArray(tools)) return out;
+    for (const tool of tools) {
+        if (tool === null || typeof tool !== 'object' || Array.isArray(tool)) continue;
+        const files = (tool as Record<string, unknown>)['files'];
+        if (!Array.isArray(files)) continue;
+        for (const entry of files) {
+            if (entry === null || typeof entry !== 'object' || Array.isArray(entry)) continue;
+            const raw = (entry as Record<string, unknown>)['path'];
+            if (typeof raw !== 'string' || raw === '') continue;
+            out.add(path.resolve(projectRoot, _expanduser(raw)));
+        }
+    }
+    return out;
+}
+
+/** Expand a leading `~`, matching the three sibling manifest readers. */
+function _expanduser(p: string): string {
+    if (p === '~') return os.homedir();
+    if (p.startsWith('~/') || (process.platform === 'win32' && p.startsWith('~\\'))) {
+        return path.join(os.homedir(), p.slice(2));
+    }
+    return p;
+}
+
+export interface SkillOriginOptions {
+    /** Pre-read claim set, to avoid a second manifest read. `null` = no manifest. */
+    claims?: ReadonlySet<string> | null;
+    /** Maintainer checkout root whose `src/skills` is the authored tree. */
+    packageRoot?: string;
+}
+
+/**
+ * Resolve one `SKILL.md` path to the origin of the skill it defines.
+ *
+ * NO CLAIM RECORD MEANS NO QUALIFIER. With no manifest, nothing on disk carries
+ * evidence that any skill is foreign, so everything resolves to `package`, the
+ * ranker qualifies nothing, and its output is exactly what it was before this
+ * function existed. That is deliberate rather than a gap being tolerated: a
+ * `home:` prefix asserted without a claim record is a guess printed in the shape
+ * of a fact, and a reader cannot tell the two apart. The cost is stated rather
+ * than hidden — where no manifest exists a foreign skill is invisible here, and
+ * the thing that fixes it is running an install, not loosening this rule.
+ *
+ * The authored tree is the one exception, and it is a construction rather than a
+ * guess: `<root>/src/skills` exists only in a maintainer checkout of THIS
+ * package and holds its source of truth, so nothing foreign can be under it.
+ */
+export function makeSkillOriginResolver(
+    projectRoot: string,
+    opts: SkillOriginOptions = {},
+): (skillMdPath: string) => SkillOrigin {
+    const claims = opts.claims !== undefined ? opts.claims : packageClaimedPaths(projectRoot);
+    const root = path.resolve(projectRoot);
+    const authored = path.join(path.resolve(opts.packageRoot ?? projectRoot), AUTHORED_SKILL_ROOT);
+    const under = (abs: string, dir: string): boolean =>
+        abs === dir || abs.startsWith(dir + path.sep);
+    return (skillMdPath: string): SkillOrigin => {
+        const abs = path.resolve(skillMdPath);
+        if (under(abs, authored)) return 'package';
+        if (claims === null) return 'package';
+        if (claims.has(abs)) return 'package';
+        return under(abs, root) ? 'project' : 'home';
+    };
+}
+
+/**
+ * The one label, and the order it is decided in.
+ *
+ *   `unscanned`    — the shape scan refused the body. FIRST, because an overlap
+ *                    score is derived FROM a body this census declined to read,
+ *                    and publishing it would be the refusal cancelling itself.
+ *   `shadowed`     — one of ours carries the same bare name. Name-derived, so it
+ *                    stays true under `unscanned`; it loses the slot only
+ *                    because `unscanned` is the stronger call to action.
+ *   `overlapping`  — content similarity against one of ours at or above the
+ *                    threshold `audit_skill_overlap` already calibrates.
+ *   `unclassified` — none of the above fired. Not a clearance.
+ */
+export function classifyCompat(args: {
+    unscanned: string | null;
+    shadows: readonly string[];
+    overlaps: readonly string[];
+}): Compat {
+    if (args.unscanned !== null) return 'unscanned';
+    if (args.shadows.length > 0) return 'shadowed';
+    if (args.overlaps.length > 0) return 'overlapping';
+    return 'unclassified';
+}
+
+/** One recorded scan verdict. `unscanned` is `null` when every shape passed. */
+export interface ScanRecord {
+    qualified: string;
+    digest: string;
+    unscanned: string | null;
+}
+
+export interface ScanCache {
+    schema_version: 1;
+    entries: ScanRecord[];
+}
+
+/** Read the scan cache, or `null` when it is absent or unreadable. */
+export function readScanCache(file: string): ScanCache | null {
+    let parsed: unknown;
+    try {
+        parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
+    } catch {
+        return null;
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
+    const entries = (parsed as Record<string, unknown>)['entries'];
+    if (!Array.isArray(entries)) return null;
+    return { schema_version: 1, entries: entries as ScanRecord[] };
+}
+
+/** sha256 of a file's bytes, or `null` when it cannot be read. */
+export function fileDigest(file: string): string | null {
+    try {
+        return createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Whether a neighbour body may be indexed, and why not when it may not.
+ *
+ * THREE REFUSALS, REPORTED SEPARATELY, because they ask the maintainer for three
+ * different things: run the census, re-run it, or read the finding. A missing
+ * record is a refusal and not a pass — a gate that passes on missing evidence is
+ * satisfied by deleting the evidence, which is the opposite of a floor. The
+ * digest compare is what "a changed digest rescans first" means from the reading
+ * side: a body edited after its scan is unscanned again until the census runs.
+ */
+export function scanVerdict(
+    cache: ScanCache | null,
+    qualified: string,
+    digest: string | null,
+): { ok: true } | { ok: false; kind: string } {
+    if (cache === null) return { ok: false, kind: 'no-scan-record' };
+    const rec = cache.entries.find((e) => e.qualified === qualified);
+    if (rec === undefined) return { ok: false, kind: 'no-scan-record' };
+    if (digest === null || rec.digest !== digest) return { ok: false, kind: 'digest-changed' };
+    if (rec.unscanned !== null) return { ok: false, kind: rec.unscanned };
+    return { ok: true };
+}