vouchington-tooling 0.45.0 → 0.46.0

package/dist/session-friction/classify.mjs

@@ -1,98 +0,0 @@
-import { normalizeCommandPrefix } from "./normalize.mjs";
-import { boundedText, isWellFormedUnicode, normalizeAuditText } from "./text.mjs";
-const FAILURE_TOKENS = [
-    ['Operation not permitted', /Operation not permitted/i],
-    ['E2BIG', /\bE2BIG\b/i],
-    ['EPERM', /\bEPERM\b/i],
-];
-const CONNECTION_REFUSED = /\bECONNREFUSED\b/i;
-const URL_USERINFO = /([a-z][a-z0-9+.-]{0,31}:\/\/)[^\s/?#@]*@/gi;
-const STDERR_INSPECTION_MAX_LENGTH = 100_000;
-const COMMAND_INSPECTION_MAX_LENGTH = 10_000;
-const IPV4_OCTET = '(?:25[0-5]|2[0-4]\\d|1\\d{2}|[1-9]?\\d)';
-const LOOPBACK_ADDRESSES = [
-    new RegExp(String.raw `(?<![0-9a-z_.:-])(?:127\.${IPV4_OCTET}(?:\.${IPV4_OCTET}){2}|localhost)(?![0-9a-z_.-])`, 'i'),
-    /(?<![0-9a-z_.-])\[(?:::1|0:0:0:0:0:0:0:1)(?:%[a-z0-9_.-]+)?\](?![0-9a-z_.-])/i,
-    /(?<![0-9a-z_.:\x5b\x5d-])(?:::1|0:0:0:0:0:0:0:1)(?:%[a-z0-9_.-]+)?(?::\d{1,5})?(?![0-9a-z_.:\x5b\x5d-])/i,
-];
-const DETAIL_MAX_LENGTH = 1_000;
-function boundedTail(value, maximum) {
-    let start = Math.max(0, value.length - maximum);
-    const first = value.charCodeAt(start);
-    const previous = value.charCodeAt(start - 1);
-    if (first >= 0xdc00 && first <= 0xdfff && previous >= 0xd800 && previous <= 0xdbff)
-        start++;
-    return value.slice(start);
-}
-function boundedStderr(value) {
-    if (value.length <= STDERR_INSPECTION_MAX_LENGTH)
-        return value;
-    const headLength = Math.floor((STDERR_INSPECTION_MAX_LENGTH - 1) / 2);
-    const head = boundedText(value, headLength);
-    const tail = boundedTail(value, STDERR_INSPECTION_MAX_LENGTH - 1 - head.length);
-    return `${head}\n${tail}`;
-}
-function withoutUrlUserinfo(line) {
-    return line.includes('://') && line.includes('@') ? line.replace(URL_USERINFO, '$1') : line;
-}
-export function classifyFrictionObservation(observation) {
-    if (!observation || typeof observation !== 'object')
-        return null;
-    if (typeof observation.command !== 'string')
-        return null;
-    const command = boundedText(observation.command, COMMAND_INSPECTION_MAX_LENGTH);
-    if (!isWellFormedUnicode(command) || normalizeAuditText(command) === '')
-        return null;
-    const commandPrefix = normalizeCommandPrefix(command, observation.commandWrappers);
-    if (commandPrefix === '' || !isWellFormedUnicode(commandPrefix))
-        return null;
-    if (observation.type === 'permission-request') {
-        return {
-            kind: 'sandbox-escalation',
-            commandPrefix,
-            detail: 'permission-request',
-            outcome: 'requested',
-        };
-    }
-    if (observation.type !== 'tool-result')
-        return null;
-    if (observation.escalationDetail !== undefined &&
-        typeof observation.escalationDetail !== 'string')
-        return null;
-    const escalationDetail = normalizeAuditText(boundedText(observation.escalationDetail ?? '', DETAIL_MAX_LENGTH));
-    if (!isWellFormedUnicode(escalationDetail))
-        return null;
-    if (observation.permissionOutcome !== undefined &&
-        !['approved', 'denied'].includes(observation.permissionOutcome))
-        return null;
-    const permission = escalationDetail || observation.permissionOutcome
-        ? {
-            kind: 'sandbox-escalation',
-            commandPrefix,
-            detail: escalationDetail || `permission-${observation.permissionOutcome}`,
-            outcome: observation.permissionOutcome ?? 'unknown',
-        }
-        : null;
-    const rawStderr = observation.structuredStderr;
-    if (rawStderr !== undefined && (typeof rawStderr !== 'string' || !isWellFormedUnicode(rawStderr)))
-        return null;
-    const stderr = rawStderr ? boundedStderr(rawStderr) : rawStderr;
-    if (stderr === undefined)
-        return permission;
-    const token = FAILURE_TOKENS.find(([, pattern]) => pattern.test(stderr))?.[0];
-    if (token) {
-        const failure = { kind: 'sandbox-failure', detail: `stderr matched "${token}"` };
-        return permission ? { ...permission, failure } : { ...failure, commandPrefix };
-    }
-    if (stderr.split(/\r\n|[\r\n]/).some((rawLine) => {
-        const line = withoutUrlUserinfo(rawLine);
-        return (CONNECTION_REFUSED.test(line) && LOOPBACK_ADDRESSES.some((pattern) => pattern.test(line)));
-    })) {
-        const failure = {
-            kind: 'ambiguous-failure',
-            detail: 'localhost connection refused; sandbox cause unverified',
-        };
-        return permission ? { ...permission, failure } : { ...failure, commandPrefix };
-    }
-    return permission;
-}

package/dist/session-friction/command-segments.d.mts

@@ -1,3 +0,0 @@
-export declare const REDACTED_TOKEN = "[REDACTED]";
-export declare function splitCommand(command: string): string[][];
-export declare function stripAssignments(tokens: string[]): string[];

package/dist/session-friction/command-segments.mjs

@@ -1,94 +0,0 @@
-export const REDACTED_TOKEN = '[REDACTED]';
-const ENV_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
-const ENV_OPTIONS_WITH_ARGS = new Set(['-C', '--chdir', '-S', '--split-string', '-u', '--unset']);
-const ENV_OPTIONS_WITHOUT_ARGS = new Set([
-    '-i',
-    '--ignore-environment',
-    '-0',
-    '--null',
-    '-v',
-    '--debug',
-]);
-export function splitCommand(command) {
-    const result = [];
-    let segment = [];
-    let word = '';
-    let quote;
-    let escaped = false;
-    const flushWord = () => {
-        if (word)
-            segment.push(word);
-        word = '';
-    };
-    const flushSegment = () => {
-        flushWord();
-        if (segment.length)
-            result.push(segment);
-        segment = [];
-    };
-    for (const char of command) {
-        if (escaped) {
-            word += char;
-            escaped = false;
-        }
-        else if (char === '\\' && quote !== "'") {
-            escaped = true;
-        }
-        else if (quote) {
-            if (char === quote)
-                quote = undefined;
-            else
-                word += char;
-        }
-        else if (char === '"' || char === "'")
-            quote = char;
-        else if (';&|<>\n\r'.includes(char))
-            flushSegment();
-        else if (/\s/.test(char))
-            flushWord();
-        else
-            word += char;
-    }
-    if (escaped)
-        word += '\\';
-    flushSegment();
-    return result;
-}
-export function stripAssignments(tokens) {
-    let index = 0;
-    while (index < tokens.length && ENV_ASSIGNMENT.test(tokens[index]))
-        index++;
-    const wrapper = tokens[index];
-    // Assignments without an executable are represented by a safe sentinel.
-    if (wrapper !== 'env' && !wrapper?.endsWith('/env'))
-        return index < tokens.length ? tokens.slice(index) : index ? [REDACTED_TOKEN] : tokens;
-    index++;
-    while (index < tokens.length) {
-        const option = tokens[index];
-        if (option === '--') {
-            index++;
-            break;
-        }
-        const optionName = option.split('=', 1)[0];
-        const splitStringOption = optionName === '-S' || (optionName.length >= 5 && '--split-string'.startsWith(optionName));
-        if (splitStringOption)
-            return [REDACTED_TOKEN];
-        const abbreviatedArgument = optionName.length >= 5 && '--chdir'.startsWith(optionName);
-        if (ENV_OPTIONS_WITH_ARGS.has(optionName) || abbreviatedArgument) {
-            index += option.includes('=') ? 1 : 2;
-            continue;
-        }
-        if (ENV_OPTIONS_WITHOUT_ARGS.has(option)) {
-            index++;
-            continue;
-        }
-        if (option.startsWith('-'))
-            return [REDACTED_TOKEN];
-        break;
-    }
-    while (index < tokens.length && ENV_ASSIGNMENT.test(tokens[index]))
-        index++;
-    if (index < tokens.length)
-        return tokens.slice(index);
-    return tokens.some((token) => ENV_ASSIGNMENT.test(token)) ? [REDACTED_TOKEN] : [];
-}

package/dist/session-friction/coverage-ledger.d.mts

@@ -1,10 +0,0 @@
-export type CoverageLedger = {
-    schemaVersion: 1;
-    retainedEvents: number;
-    logBytes: number;
-    droppedCount: number;
-};
-/** Caller holds the event log lock; incomplete atomic updates must never imply complete capture. */
-export declare function readCoverageLedger(path: string): CoverageLedger | undefined;
-/** The fixed-size atomic sidecar keeps saturation work independent of the accumulated drop count. */
-export declare function writeCoverageLedger(path: string, ledger: CoverageLedger): void;

package/dist/session-friction/coverage-ledger.mjs

@@ -1,75 +0,0 @@
-import { closeSync, constants, fsyncSync, lstatSync, openSync, renameSync } from 'node:fs';
-import { dirname } from 'node:path';
-import { openLogFile, readLogContent, writeAll, LOG_MAX_BYTES } from "./log-file.mjs";
-const LEDGER_MAX_BYTES = 192;
-function missing(error) {
-    return !!error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT';
-}
-/** Caller holds the event log lock; incomplete atomic updates must never imply complete capture. */
-export function readCoverageLedger(path) {
-    try {
-        lstatSync(`${path}.coverage.pending`);
-        throw new Error('session-friction coverage update is incomplete');
-    }
-    catch (error) {
-        if (!missing(error))
-            throw error;
-    }
-    let descriptor;
-    try {
-        descriptor = openLogFile(`${path}.coverage`, constants.O_RDONLY);
-    }
-    catch (error) {
-        if (missing(error))
-            return undefined;
-        throw error;
-    }
-    try {
-        const value = JSON.parse(readLogContent(descriptor, LEDGER_MAX_BYTES));
-        if (!value || typeof value !== 'object')
-            throw new Error('invalid session-friction coverage ledger');
-        // oxlint-disable-next-line no-mistakes/ts-no-const-aliases -- establish a validated object view
-        const item = value;
-        if (Object.keys(item).length !== 4 ||
-            item.schemaVersion !== 1 ||
-            !Number.isSafeInteger(item.retainedEvents) ||
-            item.retainedEvents < 0 ||
-            item.retainedEvents > 500 ||
-            !Number.isSafeInteger(item.logBytes) ||
-            item.logBytes < 0 ||
-            item.logBytes > LOG_MAX_BYTES ||
-            !Number.isSafeInteger(item.droppedCount) ||
-            item.droppedCount < 1)
-            throw new Error('invalid session-friction coverage ledger');
-        return item;
-    }
-    finally {
-        closeSync(descriptor);
-    }
-}
-/** The fixed-size atomic sidecar keeps saturation work independent of the accumulated drop count. */
-export function writeCoverageLedger(path, ledger) {
-    if (!Number.isSafeInteger(ledger.droppedCount))
-        throw new Error('session-friction dropped count overflow; capture incomplete');
-    const temporary = `${path}.coverage.pending`;
-    const descriptor = openSync(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW, 0o600);
-    try {
-        syncDirectory(path);
-        writeAll(descriptor, JSON.stringify(ledger));
-        fsyncSync(descriptor);
-    }
-    finally {
-        closeSync(descriptor);
-    }
-    renameSync(temporary, `${path}.coverage`);
-    syncDirectory(path);
-}
-function syncDirectory(path) {
-    const descriptor = openSync(dirname(path), constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        fsyncSync(descriptor);
-    }
-    finally {
-        closeSync(descriptor);
-    }
-}

package/dist/session-friction/directory.d.mts

@@ -1 +0,0 @@
-export declare function ensurePrivateDirectory(directory: string, create: boolean): boolean;

package/dist/session-friction/directory.mjs

@@ -1,71 +0,0 @@
-import { chmodSync, lstatSync, mkdirSync, statSync } from 'node:fs';
-import { dirname } from 'node:path';
-const PRIVATE_DIRECTORY_MODE = 0o700;
-function isCode(error, code) {
-    return Boolean(error && typeof error === 'object' && 'code' in error && error.code === code);
-}
-function directoryChain(directory) {
-    const chain = [directory];
-    let current = directory;
-    while (dirname(current) !== current) {
-        current = dirname(current);
-        chain.push(current);
-    }
-    return chain.reverse();
-}
-export function ensurePrivateDirectory(directory, create) {
-    const chain = directoryChain(directory);
-    const effectiveUserId = process.geteuid?.();
-    if (effectiveUserId === undefined)
-        throw new Error('session-friction requires POSIX directory permissions');
-    for (const [index, path] of chain.entries()) {
-        let created = false;
-        let status;
-        try {
-            status = lstatSync(path);
-        }
-        catch (error) {
-            /* v8 ignore next -- unexpected filesystem errors are propagated unchanged. */
-            if (!isCode(error, 'ENOENT'))
-                throw error;
-            if (!create)
-                return false;
-            try {
-                mkdirSync(path, { mode: PRIVATE_DIRECTORY_MODE });
-                created = true;
-            }
-            catch (mkdirError) {
-                /* v8 ignore next -- another process can create the directory after lstat. */
-                if (!isCode(mkdirError, 'EEXIST'))
-                    throw mkdirError;
-            }
-            status = lstatSync(path);
-        }
-        const leaf = index === chain.length - 1;
-        if (status.isSymbolicLink()) {
-            if (leaf || status.uid !== 0)
-                throw new Error('session-friction log directory must be a private directory');
-            try {
-                status = statSync(path);
-            }
-            catch {
-                throw new Error('session-friction log directory must be a private directory');
-            }
-        }
-        if (!status.isDirectory())
-            throw new Error('session-friction log directory must be a private directory');
-        if (created)
-            chmodSync(path, PRIVATE_DIRECTORY_MODE);
-        if (!created) {
-            const ownedByCaller = status.uid === effectiveUserId;
-            const ownedByRoot = status.uid === 0;
-            const writableByOthers = (status.mode & 0o022) !== 0;
-            const sticky = (status.mode & 0o1000) !== 0;
-            if ((leaf && ((status.mode & 0o777) !== PRIVATE_DIRECTORY_MODE || !ownedByCaller)) ||
-                (!leaf && !ownedByCaller && !ownedByRoot) ||
-                (!leaf && writableByOthers && !sticky))
-                throw new Error('session-friction log directory must be a private directory');
-        }
-    }
-    return true;
-}

package/dist/session-friction/index.d.mts

@@ -1,6 +0,0 @@
-export { classifyFrictionObservation } from './classify.mts';
-export { normalizeCommandPrefix } from './normalize.mts';
-export { FRICTION_LOG_MAX_EVENTS, readFrictionLog, recordFriction } from './log.mts';
-export { buildSessionFrictionReport, loadFrictionReportInputs, renderFrictionReport, type FrictionReportInputs, } from './report.mts';
-export { isConformingCiFailureBlock } from './ci-failures.mts';
-export type { FrictionEvent, FrictionEventKind, FrictionLogOptions, FrictionLogReadResult, FrictionObservation, JournalEntry, JournalLoadResult, JournalLoader, PermissionRequestObservation, SessionFrictionReport, SessionFrictionCoverage, SessionFrictionReportOptions, ToolResultObservation, } from './types.mts';

package/dist/session-friction/index.mjs

@@ -1,5 +0,0 @@
-export { classifyFrictionObservation } from "./classify.mjs";
-export { normalizeCommandPrefix } from "./normalize.mjs";
-export { FRICTION_LOG_MAX_EVENTS, readFrictionLog, recordFriction } from "./log.mjs";
-export { buildSessionFrictionReport, loadFrictionReportInputs, renderFrictionReport, } from "./report.mjs";
-export { isConformingCiFailureBlock } from "./ci-failures.mjs";

package/dist/session-friction/log-file.d.mts

@@ -1,7 +0,0 @@
-import type { FrictionEvent } from './types.mts';
-export declare const LOG_MAX_BYTES = 2000000;
-export declare function validEvent(value: unknown): value is FrictionEvent;
-export declare function openLogFile(path: string, flags: number): number;
-export declare function readLogContent(descriptor: number, maximumBytes?: number): string;
-export declare function validEventCount(content: string, limit: number): number;
-export declare function writeAll(descriptor: number, value: string): void;

package/dist/session-friction/log-file.mjs

@@ -1,95 +0,0 @@
-import { closeSync, constants, fstatSync, openSync, readSync, writeSync } from 'node:fs';
-import { isSafeAuditText } from "./text.mjs";
-import { decodeUtf8 } from "./utf8.mjs";
-export const LOG_MAX_BYTES = 2_000_000;
-export function validEvent(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    // oxlint-disable-next-line no-mistakes/ts-no-const-aliases -- establish a record view after the runtime object check
-    const record = value;
-    return ((record.kind === 'sandbox-escalation' ||
-        record.kind === 'sandbox-failure' ||
-        record.kind === 'ambiguous-failure') &&
-        isSafeAuditText(record.timestamp) &&
-        isSafeAuditText(record.commandPrefix) &&
-        isSafeAuditText(record.detail) &&
-        (record.failure === undefined || validFailure(record.failure)) &&
-        (record.outcome === undefined ||
-            (typeof record.outcome === 'string' &&
-                ['requested', 'approved', 'denied', 'unknown'].includes(record.outcome))));
-}
-function validFailure(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    // oxlint-disable-next-line no-mistakes/ts-no-const-aliases -- establish a validated object view
-    const failure = value;
-    return (Object.keys(failure).length === 2 &&
-        (failure.kind === 'sandbox-failure' || failure.kind === 'ambiguous-failure') &&
-        isSafeAuditText(failure.detail));
-}
-export function openLogFile(path, flags) {
-    let descriptor;
-    try {
-        descriptor = openSync(path, flags | constants.O_NOFOLLOW | constants.O_NONBLOCK, 0o600);
-    }
-    catch (error) {
-        if (error &&
-            typeof error === 'object' &&
-            'code' in error &&
-            (error.code === 'ELOOP' || error.code === 'EISDIR' || error.code === 'ENOTDIR'))
-            throw new Error('session-friction log must be a regular file');
-        throw error;
-    }
-    try {
-        const status = fstatSync(descriptor);
-        if (!status.isFile() || status.nlink !== 1)
-            throw new Error('session-friction log must be a regular file');
-        return descriptor;
-    }
-    catch (error) {
-        closeSync(descriptor);
-        throw error;
-    }
-}
-export function readLogContent(descriptor, maximumBytes = LOG_MAX_BYTES) {
-    if (fstatSync(descriptor).size > maximumBytes)
-        throw new Error('session-friction log is too large');
-    const buffer = Buffer.alloc(maximumBytes + 1);
-    let length = 0;
-    while (length < buffer.length) {
-        const bytes = readSync(descriptor, buffer, length, buffer.length - length, length);
-        if (bytes === 0)
-            break;
-        length += bytes;
-    }
-    /* v8 ignore next -- detects external growth after the descriptor size check. */
-    if (length > maximumBytes)
-        throw new Error('session-friction log is too large');
-    return decodeUtf8(buffer.subarray(0, length));
-}
-export function validEventCount(content, limit) {
-    let count = 0;
-    for (const line of content.split('\n')) {
-        if (!line.trim())
-            continue;
-        try {
-            if (validEvent(JSON.parse(line)))
-                count++;
-        }
-        catch { }
-        if (count >= limit)
-            break;
-    }
-    return count;
-}
-export function writeAll(descriptor, value) {
-    const buffer = Buffer.from(value);
-    let offset = 0;
-    while (offset < buffer.length) {
-        const written = writeSync(descriptor, buffer, offset, buffer.length - offset);
-        /* v8 ignore next -- a zero-byte synchronous file write is an external I/O failure. */
-        if (written === 0)
-            throw new Error('session-friction log write made no progress');
-        offset += written;
-    }
-}

package/dist/session-friction/log.d.mts

@@ -1,8 +0,0 @@
-import type { FrictionLogOptions, FrictionLogReadResult, FrictionObservation } from './types.mts';
-export declare const FRICTION_LOG_MAX_EVENTS = 500;
-export declare function requireDirectory(directory: string): string;
-export declare function eventLimit(maxEvents: number | undefined): number;
-export declare function recordFriction(sessionId: string, observation: FrictionObservation, options: FrictionLogOptions & {
-    timestamp?: string | (() => string);
-}): void;
-export declare function readFrictionLog(sessionId: string, options: FrictionLogOptions): FrictionLogReadResult;

package/dist/session-friction/log.mjs

@@ -1,163 +0,0 @@
-import { readCoverageLedger, writeCoverageLedger } from "./coverage-ledger.mjs";
-import { closeSync, constants, fchmodSync, fstatSync } from 'node:fs';
-import { isAbsolute, join, resolve } from 'node:path';
-import { classifyFrictionObservation } from "./classify.mjs";
-import { ensurePrivateDirectory } from "./directory.mjs";
-import { withFileLock } from "./lock.mjs";
-import { validEventCount, LOG_MAX_BYTES, openLogFile, readLogContent, validEvent, writeAll, } from "./log-file.mjs";
-import { sanitizeSessionId } from "./session-id.mjs";
-import { boundedText, isWellFormedUnicode, normalizeAuditText } from "./text.mjs";
-export const FRICTION_LOG_MAX_EVENTS = 500;
-const EVENT_FIELD_MAX_LENGTH = 1_000;
-export function requireDirectory(directory) {
-    if (typeof directory !== 'string')
-        throw new Error('log directory must be a string');
-    if (Buffer.byteLength(directory) > 4096)
-        throw new Error('session-friction log directory path is too long');
-    if (!isAbsolute(directory))
-        throw new Error('session-friction log directory must be absolute');
-    return resolve(directory);
-}
-export function eventLimit(maxEvents) {
-    const limit = maxEvents ?? FRICTION_LOG_MAX_EVENTS;
-    if (!Number.isInteger(limit) || limit < 1)
-        throw new Error('maxEvents must be a positive integer');
-    return Math.min(limit, FRICTION_LOG_MAX_EVENTS);
-}
-function logPath(sessionId, directory) {
-    return join(requireDirectory(directory), `${sanitizeSessionId(sessionId)}.jsonl`);
-}
-export function recordFriction(sessionId, observation, options) {
-    const maxEvents = eventLimit(options.maxEvents);
-    const timestamp = typeof options.timestamp === 'function' ? options.timestamp() : options.timestamp;
-    if (timestamp !== undefined && typeof timestamp !== 'string')
-        throw new Error('timestamp must be a string');
-    const rawTimestamp = timestamp ?? new Date().toISOString();
-    const normalizedTimestamp = normalizeAuditText(boundedText(rawTimestamp, EVENT_FIELD_MAX_LENGTH));
-    if (!normalizedTimestamp)
-        throw new Error('timestamp must be non-empty');
-    if (!isWellFormedUnicode(normalizedTimestamp))
-        throw new Error('timestamp must be well-formed Unicode');
-    const classified = classifyFrictionObservation(observation);
-    const path = logPath(sessionId, options.directory);
-    const directory = requireDirectory(options.directory);
-    ensurePrivateDirectory(directory, true);
-    withFileLock(path, () => {
-        /* v8 ignore next 2 -- requires the directory path to be replaced after its lock is acquired. */
-        if (!ensurePrivateDirectory(directory, false))
-            throw new Error('session-friction log directory disappeared while acquiring the lock');
-        const descriptor = openLogFile(path, constants.O_CREAT | constants.O_RDWR | constants.O_APPEND);
-        try {
-            fchmodSync(descriptor, 0o600);
-            if (fstatSync(descriptor).size > LOG_MAX_BYTES)
-                throw new Error('session-friction log is too large');
-            if (!classified)
-                return;
-            const coverage = readCoverageLedger(path);
-            const logBytes = fstatSync(descriptor).size;
-            if (coverage && coverage.logBytes === logBytes && coverage.retainedEvents >= maxEvents) {
-                writeCoverageLedger(path, { ...coverage, droppedCount: coverage.droppedCount + 1 });
-                return;
-            }
-            const content = readLogContent(descriptor);
-            const retainedEvents = validEventCount(content, FRICTION_LOG_MAX_EVENTS);
-            if (retainedEvents >= maxEvents) {
-                writeCoverageLedger(path, {
-                    schemaVersion: 1,
-                    logBytes,
-                    retainedEvents,
-                    droppedCount: (coverage?.droppedCount ?? 0) + 1,
-                });
-                return;
-            }
-            const event = {
-                ...classified,
-                commandPrefix: normalizeAuditText(classified.commandPrefix),
-                detail: normalizeAuditText(classified.detail),
-                timestamp: normalizedTimestamp,
-            };
-            /* v8 ignore next -- normalized classified fields satisfy validEvent defensively. */
-            if (!validEvent(event))
-                return;
-            const prefix = content && !content.endsWith('\n') ? '\n' : '';
-            const addition = `${prefix}${JSON.stringify(event)}\n`;
-            if (logBytes + Buffer.byteLength(addition) > LOG_MAX_BYTES) {
-                writeCoverageLedger(path, {
-                    schemaVersion: 1,
-                    logBytes,
-                    retainedEvents,
-                    droppedCount: (coverage?.droppedCount ?? 0) + 1,
-                });
-                return;
-            }
-            writeAll(descriptor, addition);
-            if (coverage)
-                writeCoverageLedger(path, {
-                    ...coverage,
-                    logBytes: fstatSync(descriptor).size,
-                    retainedEvents: retainedEvents + 1,
-                });
-        }
-        finally {
-            closeSync(descriptor);
-        }
-    });
-}
-export function readFrictionLog(sessionId, options) {
-    const maxEvents = eventLimit(options.maxEvents);
-    const path = logPath(sessionId, options.directory);
-    const directory = requireDirectory(options.directory);
-    if (!ensurePrivateDirectory(directory, false))
-        return { status: 'absent' };
-    try {
-        return withFileLock(path, () => {
-            /* v8 ignore next -- detects directory removal after acquiring the file lock. */
-            if (!ensurePrivateDirectory(directory, false))
-                return { status: 'absent' };
-            const descriptor = openLogFile(path, constants.O_RDONLY);
-            try {
-                const events = [];
-                const ledger = readCoverageLedger(path);
-                let droppedCount = ledger?.droppedCount ?? 0;
-                let retainedEvents = 0;
-                for (const line of readLogContent(descriptor).split('\n')) {
-                    if (!line.trim())
-                        continue;
-                    try {
-                        const value = JSON.parse(line);
-                        if (validEvent(value)) {
-                            retainedEvents++;
-                            if (events.length < maxEvents)
-                                events.push(value);
-                            else
-                                droppedCount++;
-                        }
-                        else
-                            droppedCount++;
-                    }
-                    catch {
-                        droppedCount++;
-                    }
-                }
-                if (ledger &&
-                    (ledger.logBytes !== fstatSync(descriptor).size ||
-                        ledger.retainedEvents !== Math.min(retainedEvents, FRICTION_LOG_MAX_EVENTS)))
-                    throw new Error('session-friction coverage ledger does not match retained log');
-                if (!Number.isSafeInteger(droppedCount))
-                    throw new Error('session-friction dropped count overflow; capture incomplete');
-                const coverage = droppedCount ? { truncated: true, droppedCount } : {};
-                return events.length
-                    ? { status: 'events', events, ...coverage }
-                    : { status: 'empty', ...coverage };
-            }
-            finally {
-                closeSync(descriptor);
-            }
-        });
-    }
-    catch (error) {
-        if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT')
-            return { status: 'absent' };
-        throw error;
-    }
-}

package/dist/session-friction/normalize.d.mts

@@ -1 +0,0 @@
-export declare function normalizeCommandPrefix(command: string, wrappersToStrip?: string[]): string;