@event4u/agent-config 17.0.0 → 17.1.0

package/src/install/conflictTracker.ts

@@ -28,11 +28,13 @@ import {
     decideDeployWrite,
     foreignSidecarMessage,
     isLedgerMigration,
+    logProofApplies,
     migrationPreservedMessage,
     preservedFileMessage,
     sidecarPathFor,
     type DeployWriteDecision,
 } from './preserve.js';
+import { loggedWriteDigests, wroteTheseBytes, type LoggedWrites } from './loggedWrites.js';
 import { ledgerListedPaths, recordedHashesWithLedger, type RecordedHashes } from './recordedOwnership.js';
 
 /**
@@ -89,6 +91,8 @@ export interface ConflictState {
      * compare a file against a listing this very run had just produced.
      */
     ledgerFiles: ReadonlySet<string> | null;
+    /** The transaction log's writes, read lazily once per run for the same reason. */
+    logged: LoggedWrites | null;
     preserved: string[];
     /**
      * Targets this run preserved on the migration branch.
@@ -148,6 +152,7 @@ export function createConflictTracker(host: ConflictTrackerHost): ConflictTracke
         root: null,
         recorded: null,
         ledgerFiles: null,
+        logged: null,
         preserved: [],
         migrated: new Set(),
         staged: new Map(),
@@ -331,6 +336,7 @@ export function createConflictTracker(host: ConflictTrackerHost): ConflictTracke
             conflictState.root = root;
             conflictState.recorded = null;
             conflictState.ledgerFiles = null;
+            conflictState.logged = null;
             conflictState.preserved = [];
             conflictState.migrated = new Set();
             conflictState.staged = new Map();
@@ -344,13 +350,23 @@ export function createConflictTracker(host: ConflictTrackerHost): ConflictTracke
          */
         resolve(target: string, force: boolean, would: WouldWrite): DeployWriteDecision {
             const exists = pathExists(target);
-            const base = {
+            const recordedSha256 = exists ? recordedHashFor(target) : undefined;
+            const unproven = {
                 exists,
-                recordedSha256: exists ? recordedHashFor(target) : undefined,
+                recordedSha256,
                 onDiskSha256: exists ? sha256OfFile(target) : null,
                 force,
                 ledgerListed: exists && ledgerLists(target),
+                recordedIsStaged:
+                    typeof recordedSha256 === 'string' && recordedSha256 === recordedHashFor(sidecarPathFor(target)),
             };
+            // The log is opened only where the record alone would preserve
+            // without cause, and read once per run: this run's own appends
+            // cannot prove a file it has not reached yet.
+            const loggedWrite =
+                logProofApplies(unproven) &&
+                wroteTheseBytes(target, unproven.onDiskSha256 as string, (conflictState.logged ??= loggedWriteDigests()));
+            const base = { ...unproven, loggedWrite };
             // The packaged digest costs a temp write and a tag, so it is
             // computed only for the targets that can consume it. On a tree
             // where every ledger-listed path carries a digest — which is every

package/src/install/installThinLayer.ts

@@ -109,6 +109,11 @@ export interface ThinInstalledLayerOptions {
      * the staged runtime, which outlives a cleared package-manager cache.
      */
     readonly bodyLinkRoot?: string | null;
+    /**
+     * Called with each path this pass rewrote — the installer logs it, because
+     * the transaction log is read back as proof the bytes on disk are ours.
+     */
+    readonly onWrite?: (target: string) => void;
 }
 
 /**
@@ -212,6 +217,7 @@ export function thinInstalledRuleLayer(opts: ThinInstalledLayerOptions): ThinIns
         try {
             if (next !== installed) {
                 fs.writeFileSync(target, next, 'utf-8');
+                opts.onWrite?.(target);
                 rewritten += 1;
             }
             thinned += 1;

package/src/install/loggedWrites.ts

@@ -0,0 +1,148 @@
+/**
+ * The install transaction log read as an ownership record.
+ *
+ * WHY. The writer preserves any managed file it cannot prove is still the bytes
+ * it wrote. For a file deployed before the ownership ledger recorded digests,
+ * the ledger has nothing to compare against, so EVERY such file was preserved
+ * and a sidecar staged beside it — thousands of them on one upgrade, all
+ * untouched. Worse, the ledger then records the staged digest for each target,
+ * so the next run calls the same untouched file "user-modified".
+ *
+ * The proof was on disk the whole time. `src/scripts/install.ts` appends a
+ * `write` entry carrying the SHA-256 of the target's bytes immediately after
+ * every copy. A file whose bytes equal a digest the log records this installer
+ * writing to that exact path is the installer's own output, unedited. A path
+ * with no matching record keeps the existing answer. WHEN that proof may decide
+ * is narrower than "whenever it matches" — see `decideDeployWrite`.
+ *
+ * WHAT IS READ. The active log and every rotated sibling, plain or gzipped
+ * (`txlog.ts` rotates at 10 MB or 30 days, and the gzip step can leave both
+ * forms behind). An unreadable or truncated file contributes nothing — the
+ * failure direction is "no proof", which preserves.
+ *
+ * COST. Parsed per FILE and cached on that file's size and mtime. A rotated
+ * archive never changes, so only the active log is re-read when it grows — and
+ * an install appends to it after every file it touches, so a cache keyed on the
+ * whole set would re-parse the entire history once per candidate.
+ */
+
+import { gunzipSync } from 'node:zlib';
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { basename, dirname, join, relative, resolve, sep } from 'node:path';
+
+import { getLogPath } from './paths.js';
+
+/** Absolute target path → every digest the log records this installer writing there. */
+export type LoggedWrites = ReadonlyMap<string, ReadonlySet<string>>;
+
+const WRITE_MARKER = '"kind":"write"';
+
+const fileCache = new Map<string, { readonly stamp: string; readonly entries: ReadonlyArray<readonly [string, string]> }>();
+const dirRealpaths = new Map<string, string>();
+
+/**
+ * One canonical spelling for a path: its directory realpath'd, its basename
+ * kept. Both the log keys and the queries go through it, so `/var/…` and its
+ * macOS realpath twin meet. The directory is realpath'd rather than the file
+ * because the file may not exist, and is memoised because a log names a few
+ * hundred directories across tens of thousands of entries.
+ */
+export function canonicalPath(p: string): string {
+    const abs = resolve(p);
+    const dir = dirname(abs);
+    let real = dirRealpaths.get(dir);
+    if (real === undefined) {
+        try {
+            real = realpathSync(dir);
+        } catch {
+            real = dir;
+        }
+        dirRealpaths.set(dir, real);
+    }
+    return join(real, basename(abs));
+}
+
+/** The active log plus its rotated siblings, sorted by name. */
+function logFiles(logPath: string): string[] {
+    const dir = dirname(logPath);
+    if (!existsSync(dir)) return [];
+    const stem = basename(logPath).replace(/\.jsonl$/, '');
+    try {
+        return readdirSync(dir)
+            .filter((n) => n.startsWith(stem) && (n.endsWith('.jsonl') || n.endsWith('.jsonl.gz')))
+            .map((n) => join(dir, n))
+            .sort();
+    } catch {
+        return [];
+    }
+}
+
+function writesIn(file: string): ReadonlyArray<readonly [string, string]> {
+    let stamp: string;
+    try {
+        const st = statSync(file);
+        stamp = `${st.size}:${Math.trunc(st.mtimeMs)}`;
+    } catch {
+        return [];
+    }
+    const cached = fileCache.get(file);
+    if (cached !== undefined && cached.stamp === stamp) return cached.entries;
+
+    let text = '';
+    try {
+        const raw = readFileSync(file);
+        text = (file.endsWith('.gz') ? gunzipSync(raw) : raw).toString('utf8');
+    } catch {
+        text = '';
+    }
+    const entries: Array<readonly [string, string]> = [];
+    for (const line of text.split('\n')) {
+        if (!line.includes(WRITE_MARKER)) continue;
+        let entry: { path?: unknown; sha256?: unknown };
+        try {
+            entry = JSON.parse(line) as { path?: unknown; sha256?: unknown };
+        } catch {
+            continue;
+        }
+        if (typeof entry.path !== 'string' || typeof entry.sha256 !== 'string' || entry.sha256 === '') continue;
+        entries.push([canonicalPath(entry.path), entry.sha256]);
+    }
+    fileCache.set(file, { stamp, entries });
+    return entries;
+}
+
+/** Every `write` the transaction log records, keyed by canonical path. */
+export function loggedWriteDigests(logPath: string = getLogPath()): LoggedWrites {
+    const writes = new Map<string, Set<string>>();
+    for (const file of logFiles(logPath)) {
+        for (const [target, sha] of writesIn(file)) {
+            let set = writes.get(target);
+            if (set === undefined) writes.set(target, (set = new Set()));
+            set.add(sha);
+        }
+    }
+    return writes;
+}
+
+/**
+ * Wrap a log writer so it records only paths this run's copy deploys.
+ *
+ * The claude-code rewrite and thinning passes walk the whole rule directory,
+ * including rules the user authored there; logging those rewrites would make
+ * the log vouch for content that was never the package's.
+ */
+export function onlyDeployed(
+    anchor: string,
+    currentFiles: ReadonlySet<string>,
+    log: (target: string) => void,
+): (target: string) => void {
+    return (target) => {
+        const rel = relative(resolve(anchor), resolve(target)).split(sep).join('/');
+        if (currentFiles.has(rel)) log(target);
+    };
+}
+
+/** Did this installer write exactly `onDiskSha256` to `target`? */
+export function wroteTheseBytes(target: string, onDiskSha256: string, writes: LoggedWrites): boolean {
+    return writes.get(canonicalPath(target))?.has(onDiskSha256) === true;
+}

package/src/install/paths.ts

@@ -69,12 +69,21 @@ export function getInstallRoot(home?: string): string {
 }
 
 /**
- * Absolute path to the active transaction log:
- * `~/.event4u/agent-config/install-log.jsonl`.
+ * Absolute path to the active transaction log: `install-log.jsonl` in
+ * `$EVENT4U_CONFIG_HOME` when that is set and no explicit `home` is given,
+ * otherwise in `~/.event4u/agent-config/`.
  *
  * Phase A4 writers append here on every successful atomic rename.
+ *
+ * Without the variable, the hermetic test environment — which sets only that
+ * variable — appended every test install to the real user's log, and the log
+ * is now read back as ownership proof. A history written under the other root
+ * before a user switched roots is not read; the failure direction is "no
+ * proof", which preserves.
  */
 export function getLogPath(home?: string): string {
+    const configHome = home ? undefined : process.env['EVENT4U_CONFIG_HOME'];
+    if (configHome) return join(configHome, INSTALL_LOG_FILENAME);
     return join(getInstallRoot(home), INSTALL_LOG_FILENAME);
 }
 

package/src/install/preserve.ts

@@ -109,6 +109,23 @@ export interface DeployWriteInputs {
      * `null` when the file could not be read.
      */
     readonly onDiskSha256: string | null;
+    /**
+     * True when the install transaction log records this installer writing
+     * exactly the bytes now on disk to this path (`./loggedWrites.ts`).
+     * Absent means false. Decides only where {@link logProofApplies} says so.
+     */
+    readonly loggedWrite?: boolean;
+    /**
+     * True when the recorded digest is the one this installer STAGED beside the
+     * target as a sidecar, rather than bytes it wrote to the target itself.
+     *
+     * The ledger records a preserved target under the staged digest, so such a
+     * target reads `recorded-modified` without anyone having edited it. Only
+     * then may the log override the record: a recorded digest of bytes we DID
+     * write diverging from disk is a real edit — including a user restoring an
+     * older shipped version on purpose, which the log would also match.
+     */
+    readonly recordedIsStaged?: boolean;
     /** True when the run carries `--force`. */
     readonly force: boolean;
 }
@@ -135,18 +152,36 @@ export interface DeployWriteInputs {
  * behaviour stands rather than being changed on a case nobody reasoned about.
  */
 export function isLedgerMigration(inputs: Omit<DeployWriteInputs, 'packagedSha256'>): boolean {
-    if (!inputs.exists || inputs.force) return false;
+    if (!inputs.exists || inputs.force || inputs.loggedWrite === true) return false;
     if (inputs.ledgerListed !== true) return false;
     if (inputs.onDiskSha256 === null) return false;
     return classifyOwnership(inputs.recordedSha256, inputs.onDiskSha256) === 'unknown';
 }
 
+/**
+ * May the transaction-log proof decide this target? Only where the verdict
+ * would otherwise be a preservation the record cannot justify: a ledger-listed
+ * file with no digest (the migration branch), or a `recorded-modified` file
+ * whose recorded digest is a staged one. Everywhere else the log is not read —
+ * the ledger alone already decides, and a genuine edit must stay preserved.
+ */
+export function logProofApplies(inputs: Omit<DeployWriteInputs, 'packagedSha256' | 'loggedWrite'>): boolean {
+    if (!inputs.exists || inputs.force || inputs.onDiskSha256 === null) return false;
+    const ownership = classifyOwnership(inputs.recordedSha256, inputs.onDiskSha256);
+    if (ownership === 'recorded-modified') return inputs.recordedIsStaged === true;
+    // `loggedWrite` is cleared because `isLedgerMigration` excludes a proven
+    // target, and this asks whether the target is a candidate BEFORE the proof.
+    return ownership === 'unknown' && isLedgerMigration({ ...inputs, loggedWrite: false });
+}
+
 /**
  * Decide whether the writer may replace one managed file.
  *
- * A target that does not exist is written. A forced run writes. Otherwise the
- * recorded-ownership verdict decides: `recorded-modified` preserves, and
- * `recorded-unchanged` writes.
+ * A target that does not exist is written. A forced run writes. A target whose
+ * bytes the transaction log records this installer writing there is written
+ * where {@link logProofApplies} — there is no edit to lose. Otherwise the
+ * recorded-ownership verdict decides:
+ * `recorded-modified` preserves, and `recorded-unchanged` writes.
  *
  * The `unknown` arm is the one worth stating out loud. No recorded digest
  * means no divergence to measure — a tree with no manifest, a global anchor
@@ -169,6 +204,7 @@ export function isLedgerMigration(inputs: Omit<DeployWriteInputs, 'packagedSha25
 export function decideDeployWrite(inputs: DeployWriteInputs): DeployWriteDecision {
     if (!inputs.exists) return 'write';
     if (inputs.force) return 'write';
+    if (inputs.loggedWrite === true && logProofApplies(inputs)) return 'write';
     const ownership = classifyOwnership(inputs.recordedSha256, inputs.onDiskSha256);
     if (ownership === 'recorded-modified') return 'preserve';
     if (ownership === 'unknown' && isLedgerMigration(inputs)) {

package/src/install/txlog.ts

@@ -6,14 +6,18 @@
  * nothing is un-written automatically. No PID lockfile (per Phase-A4
  * decision 8).
  *
- * WHAT ACTUALLY WRITES THIS FILE, as of 2026-09-15: two call sites.
- * `src/server/routes/install.ts`'s recovery-dismiss handler appends a
- * `rollback` marker with an empty path and a null hash; `src/scripts/install.ts`
- * — the surviving headless writer, per-file, through `_log_tx_entry` — appends
- * a `write` or `skip` entry per copied/skipped path during
- * `_copy_dir_dereferencing_symlinks`. Both call `appendTxLog` directly, so the
+ * WHAT ACTUALLY WRITES THIS FILE: `src/server/routes/install.ts`'s
+ * recovery-dismiss handler appends a `rollback` marker with an empty path and a
+ * null hash; `src/scripts/install.ts`, through `_log_tx_entry`, appends a
+ * `write` or `skip` entry per path it copies, preserves or stages a sidecar
+ * for, and a `write` entry per deployed Claude rule the host-form rewrite and
+ * the thinning pass rewrite after the copy. All call `appendTxLog`, so the
  * entry shape is identical by construction rather than by convention.
  *
+ * WHAT READS IT: recovery (the active log only) and `./loggedWrites.ts`, which
+ * reads every `write` digest in the active log AND its rotated siblings as
+ * proof that bytes on disk are the installer's own output.
+ *
  * Rotation: 10 MB OR 30 days, whichever first. Rotated copies move to
  * `install-log.<ISO>.jsonl.gz` siblings; recovery never scans them.
  *

package/src/scripts/_cli/cmd_conformance.ts

@@ -39,6 +39,7 @@ import * as YAML from 'yaml';
 
 import * as installed_tools from '../_lib/installed_tools.js';
 import { atomicAppendLine } from '../../install/atomic.js';
+import { getLogPath } from '../../install/paths.js';
 import { readRecentEntries } from '../../install/txlog.js';
 import { detectToolPresence } from '../../install/detect.js';
 import { resolvePackageRoot } from '../_lib/package_root.js';
@@ -120,13 +121,13 @@ export function conformanceLogPath(): string {
     return path.join(os.homedir(), '.event4u', 'agent-config', 'conformance-log.jsonl');
 }
 
-/** Default install txlog path (kept in sync with `src/install/txlog.ts` docs). */
+/** Install txlog path — the one the installer writes, via `getLogPath()`. */
 export function installLogPath(): string {
     const override = process.env['AGENT_CONFIG_INSTALL_LOG'];
     if (override && override.trim().length > 0) {
         return override;
     }
-    return path.join(os.homedir(), '.event4u', 'agent-config', 'install-log.jsonl');
+    return getLogPath();
 }
 
 // ---------------------------------------------------------------------------

package/src/scripts/_cli/cmd_update.ts

@@ -542,7 +542,7 @@ export async function main(argv: string[] | null = null, options: MainOptions =
         cache_warmer(latest);
     }
     _refresh_state(latest, latest, state_path);
-    _refresh_global_lockfile(latest, out);
+    _report_global_install(latest, out);
     return 0;
 }
 
@@ -556,30 +556,28 @@ function _relativeToOr(target: string, base: string): string {
 }
 
 /**
- * Update the global `installed.lock` if it exists.
+ * Name `agent-config upgrade` when the global install is older than the pin.
  *
- * Resolution prefers `~/.event4u/agent-config/installed.lock` and falls back to
- * the legacy `~/.config/agent-config/installed.lock`.
- *
- * Phase 1.6 — the lockfile is only present when the user has run a global
- * install; we never create one here, but we keep it in lockstep when `update`
- * flips the pin. Atomic write goes through `installed_lock.write_lockfile`.
+ * Read-only by design: `installed.lock` records what the global install
+ * deployed, and `upgrade` (plus its `--check` and unattended paths) reads it as
+ * the installed version. This command used to rewrite it to the pin, so after
+ * `update` the lock claimed a version no `npm install -g` had installed and
+ * `upgrade --check` reported "up to date" over the old binary.
  */
-function _refresh_global_lockfile(version: string, out: OutSink): void {
-    const read_path = installed_lock.lockfile_path();
-    const write_path = installed_lock.lockfile_write_path();
-    const existing = installed_lock.read_lockfile(read_path);
+function _report_global_install(version: string, out: OutSink): void {
+    const existing = installed_lock.read_lockfile(installed_lock.lockfile_path());
     if (existing === null) {
         return;
     }
     const recorded = (existing as unknown as Record<string, unknown>)['agent_config_version'];
-    const tools = [...(existing.tools ?? [])];
-    if (recorded === version && read_path === write_path) {
-        _print(out, `ℹ️  ${write_path} already records ${version}.`);
+    if (typeof recorded !== 'string' || !update_check._is_newer(version, _normalize(recorded))) {
         return;
     }
-    installed_lock.write_lockfile(version, tools, { path: write_path });
-    _print(out, `✅  Refreshed global lockfile at ${write_path}.`);
+    _print(
+        out,
+        `ℹ️  The global install is ${_normalize(recorded)}; this pin does not change it. ` +
+            `Run \`agent-config upgrade\` to install ${version} globally.`,
+    );
 }
 
 /** Read `version` from the package's own `package.json`. */

package/src/scripts/_lib/council_settings_block.ts

@@ -16,8 +16,8 @@
  * `load_settings` does not hand `build_members` the config FILE — it hands it
  * this block. So a key the loader validates and this projection drops is
  * enforced at load and invisible at runtime. That has now happened to
- * `quorum`, to `quorum_min_present`, and to `fallback.api_on_quota` in turn;
- * each carries its own comment below. A new key belongs in BOTH places or in
+ * `quorum`, to `quorum_min_present`, to `fallback.api_on_quota`, and to a
+ * member's `base_url` route fields in turn; each carries its own comment below. A new key belongs in BOTH places or in
  * neither.
  */
 
@@ -48,6 +48,13 @@ export function synthesizeAiCouncilBlock(cfg: CouncilConfig): Dict {
         if (m.prompt_cache_ttl !== '5m') {
             entry['prompt_cache_ttl'] = m.prompt_cache_ttl;
         }
+        // Dropping these turned every configured `base_url` route into an
+        // unknown provider at `build_members`, so no free route was ever built.
+        if (m.route) {
+            entry['base_url'] = m.route.base_url;
+            entry['content_ceiling'] = m.route.declared_ceiling;
+            if (m.route.proof !== null) entry['billing_proof'] = { ...m.route.proof };
+        }
         members[name] = entry;
     }
     const advisors: Dict = {};

package/src/scripts/_lib/egress_rules.ts

@@ -198,7 +198,10 @@ export function pemMaskEnd(text: string, span: SpanBounds): number | null {
 
 // IBAN length per country (ISO 13616 registry), packed as `CCnn` pairs. A country
 // missing here leaves its IBANs unmasked, so the table errs towards inclusion.
-const IBAN_LENGTHS =
+// Checked 2026-10-22 against the registry's Release 103: all 89 countries and
+// lengths agree. The test pins this release to the table's digest.
+export const IBAN_REGISTRY_RELEASE = 103;
+export const IBAN_LENGTHS =
     'AD24AE23AL28AT20AZ28BA20BE16BG22BH22BI27BR29BY28CH21CR22CY28CZ24DE22DJ27DK18DO28EE20EG29ES24FI18FK18FO18FR27GB22GE22GI23GL18GR27GT28HN28HR21HU28IE22IL23IQ23IS26IT27JO30KW30KZ20LB28LC32LI21LT20LU20LV21LY25MC27MD24ME22MK19MN20MR27MT31MU30NI28NL18NO15OM23PK24PL28PS29PT25QA29RO24RS22RU33SA24SC31SD18SE24SI19SK24SM27SO23ST25SV28TL23TN24TR26UA29VA22VG24XK20YE30';
 
 export function isValidIban(value: string): boolean {

package/src/scripts/_lib/host_capability.ts

@@ -365,19 +365,24 @@ export function resolveHostCapabilities(
  * settings decision, so there is no override parameter here (that stays on
  * {@link resolveHostCapabilities} for back-compat callers only).
  *
- * The one probed fact today: `agent_teams` resolves `true` when
+ * Two probed facts today. `agent_teams` resolves `true` when
  * `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` is set (any non-empty value) in the
  * process environment — the one host fact this repo can observe about Claude
  * Code's documented-but-unshipped-by-default multi-instance Agent Teams
  * primitive. A registry row can also carry `agent_teams: true` directly for a
  * host where it is unconditionally available; the two sources OR together —
- * a probe never turns a registry-granted capability back off.
+ * a probe never turns a registry-granted capability back off. `worker_resume`
+ * follows the same flag on `claude` only, because the by-name re-task was
+ * observed there under it and nowhere else.
  */
 export function probeHostCapabilities(hostId: string | null | undefined): HostCapabilityManifest {
     const base = resolveHostCapabilities(hostId);
     const flag = process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS;
     const probedAgentTeams = typeof flag === 'string' && flag !== '';
-    return { ...base, agent_teams: base.agent_teams || probedAgentTeams };
+    // By-name resume was observed on claude only under this flag (cold-start
+    // 1.4, 2.1.306); council 2026-10-22 decision 1 made it a live probe.
+    const probedResume = probedAgentTeams && hostId === 'claude';
+    return { ...base, agent_teams: base.agent_teams || probedAgentTeams, worker_resume: base.worker_resume || probedResume };
 }
 
 /** Every manifest field that carries a capability answer (i.e. not `schema_version`). */
@@ -448,9 +453,9 @@ export function describeHostCapabilities(
         // A row entry claims the field whatever its value: an explicit
         // `false` in the table is an observation ("checked, absent"), which is
         // a different fact from the default's "nobody answered".
-        if (row !== undefined && typeof row[field] === 'boolean') {
+        if (row !== undefined && typeof row[field] === 'boolean' && !(row[field] === false && manifest[field] === true)) {
             sources[field] = 'registry';
-        } else if (field === 'agent_teams' && probedAgentTeams) {
+        } else if ((field === 'agent_teams' || (field === 'worker_resume' && hostId === 'claude')) && probedAgentTeams) {
             sources[field] = 'live-probe';
         } else {
             sources[field] = 'default';

package/src/scripts/_lib/identifier_redaction.ts

@@ -7,11 +7,47 @@
  * error and a context word is not required here. The rows' checksums still
  * hold — a number that fails Luhn is not a card, a string that fails mod-97 is
  * not an IBAN. The tag spelling and the counter keys are this consumer's.
+ *
+ * Without the context word a digit row must stand on its own shape, so the store
+ * tightens four rows where tree text measured false positives (PREREG (b), store
+ * reading): phone and card digits may not touch a letter on either side (a
+ * digit-led hex SHA is not a card) nor follow a decimal point, and a national
+ * number may not continue a `-` or `/` list (`ADR-046/047`); a leading `+` at a line start — a diff's added
+ * line — needs a grouped number (`+49 30 …`), a dotted quad is never a phone, and
+ * a North-American number keeps its context word unless it is written formatted,
+ * because a bare ten-digit integer (`2147483647`) has the same digits.
  */
 import { detect, type EgressRule, IDENTIFIER_RULES, replaceSpans } from './egress_rules.js';
 
-/** The identifier rows with every context requirement dropped. */
-export const STORAGE_IDENTIFIER_RULES: readonly EgressRule[] = IDENTIFIER_RULES.map(({ context: _context, ...rest }) => rest);
+/** Store patterns for the rows the shape alone cannot carry; the rest are the table's own. */
+const STORE_PATTERN: Readonly<Record<string, RegExp>> = {
+    'payment-card': /(?<![0-9A-Za-z.])[0-9](?:[ -]?[0-9]){12,18}(?![0-9A-Za-z])/g,
+    'phone-international':
+        /(?<![A-Za-z0-9+])(?:(?<!^|\n)|(?=\+[1-9][0-9]{0,2}[ (]))\+[1-9][0-9]{0,2}(?:[ ./-]?(?:\([0-9]{1,6}\)|(?=([0-9]{1,6}))\1)){1,5}(?![0-9A-Za-z])/g,
+    'phone-national': /(?<![A-Za-z0-9+(./-])(?:\(0[1-9][0-9]{1,4}\)|0[1-9][0-9]{1,4})(?:[ ./-]?(?=([0-9]{2,8}))\1){1,3}(?![0-9A-Za-z])/g,
+};
+
+const DOTTED_QUAD = /^\+?[0-9]{1,3}(?:\.[0-9]{1,3}){3}$/;
+
+/** A North-American number that is written as one: two separators, or a bracketed area code. */
+function isFormattedNanp(value: string): boolean {
+    return value.includes('(') || (value.match(/[ .-]/g) ?? []).length >= 2;
+}
+
+function storeRow(row: EgressRule): EgressRule[] {
+    const { context: _context, ...rest } = row;
+    if (row.rule === 'phone-nanp') {
+        // Two rows: the table's own with its context word, and a formatted shape without one.
+        return [row, { ...rest, rule: 'phone-nanp-formatted', validator: isFormattedNanp }];
+    }
+    const pattern = STORE_PATTERN[row.rule];
+    if (!pattern) return [rest];
+    if (row.rule === 'phone-international') return [{ ...rest, pattern, exclusions: [...(rest.exclusions ?? []), DOTTED_QUAD] }];
+    return [{ ...rest, pattern }];
+}
+
+/** The identifier rows as the stores read them: context dropped, except where shape alone is not evidence. */
+export const STORAGE_IDENTIFIER_RULES: readonly EgressRule[] = IDENTIFIER_RULES.flatMap(storeRow);
 
 /** Counter key and tag per placeholder type; `CC` predates the table's `CARD`. */
 const TAG: Readonly<Record<string, string>> = { CARD: 'CC' };