vouchington-tooling 0.45.0 → 0.47.0

package/dist/private-files/log-file.mjs

@@ -0,0 +1,53 @@
+import { closeSync, constants, fstatSync, openSync, readSync, writeSync } from 'node:fs';
+import { decodeUtf8 } from "./utf8.mjs";
+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('log file must be a regular file');
+        throw error;
+    }
+    try {
+        const status = fstatSync(descriptor);
+        if (!status.isFile() || status.nlink !== 1)
+            throw new Error('log file must be a regular file');
+        return descriptor;
+    }
+    catch (error) {
+        closeSync(descriptor);
+        throw error;
+    }
+}
+export function readLogContent(descriptor, maximumBytes) {
+    if (fstatSync(descriptor).size > maximumBytes)
+        throw new Error('log file 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('log file is too large');
+    return decodeUtf8(buffer.subarray(0, length));
+}
+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('log file write made no progress');
+        offset += written;
+    }
+}

package/dist/{session-friction → private-files}/utf8.mjs

@@ -3,6 +3,6 @@ export function decodeUtf8(value) {
         return new TextDecoder('utf-8', { fatal: true }).decode(value);
     }
     catch {
-        throw new Error('session-friction log is not valid UTF-8');
+        throw new Error('log file is not valid UTF-8');
     }
 }

package/dist/retrospective-facts/exec.mjs

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
+import { ghSpawnEnv } from "../gh-cli/env.mjs";
 export const shell = (command, args) => new Promise((resolve) => {
-    const child = spawn(command, args);
+    const child = command === 'gh' ? spawn(command, args, { env: ghSpawnEnv() }) : spawn(command, args);
     let stdout = '';
     let stderr = '';
     child.stdout.setEncoding('utf8');

package/docs/mcp-server.md

@@ -286,8 +286,10 @@ shape is an error, never a pass.
 retrospective tools. All three take `sessionId` (required) and `worktree` (optional), need a server
 launched inside a repository worktree (they run the checkout policy), and share this structured
 input: `title` (single line, at most 256 characters), `summary`, `impact`, `relatedIssues`
-(`[{ number, relation: "closes" | "refs", reason }]`, may be empty), optional `noSourceIssue`
-(`{ reason }`, see below), `details` (string array), `base` (default `main`), `agent`, optional
+(`[{ number, relation: "closes" | "refs", reason, repository? }]`, may be empty; the optional
+`repository` is a single `owner/name` and renders the line as lowercase `owner/name#N`), optional
+`noSourceIssue` (`{ reason }`, see below), `details` (string array), `base` (default `main`),
+optional `agent`, optional
 `model`, optional `mode` (`interactive` | `autonomous`) and `workspaceSetup`. `pr_update` also
 requires `pr`; `pr_validate` accepts an optional `pr`.
 
@@ -305,11 +307,25 @@ argument can only narrow `interactive` to `autonomous` (it never widens), so an
 cannot unlock an interactive-only policy exception. The policy child receives no env markers, so it
 relies on this value.
 
+### Agent provenance
+
+The `Agent:` line is derived by the server, never taken from the caller. The agent is the harness
+that launched the server: `CODEX_THREAD_ID` (codex), `CLAUDECODE=1` or `CLAUDE_CODE_SESSION_ID`
+(claude), `CURSOR_AGENT` or `CURSOR_SESSION_ID` (cursor), `GROK_AGENT`, `GROK_HOOK_EVENT` or
+`GROK_SESSION_ID` (grok), in that order; failing those, the MCP client's `initialize`
+`clientInfo.name` when it contains one of those names. The server has no source for the model.
+`agent` is optional: a value naming the derived agent is ignored, any other value is rendered as
+`(caller-claimed agent: <value>)`, and `model` as `(caller-claimed model: <value>)`. When no agent
+is derivable the line says `unknown`. Making `agent` optional is compatible with existing callers,
+which may keep sending it.
+
 ### Pull requests with no source issue
 
-Pass `noSourceIssue: { reason }` (a single line) with an empty `relatedIssues`; a non-empty
-`relatedIssues` beside it is rejected. The Related issues section then holds the generic statement
-`- No source issue — <reason>` instead of `- None`. A policy may replace the statement by
+Pass `noSourceIssue: { reason }` (a single line) with an empty `relatedIssues`, or with a
+`relatedIssues` whose every entry is `refs`; a `closes` entry beside it is rejected. The Related
+issues section then holds the generic statement `- No source issue — <reason>` instead of `- None`,
+preceded by the `- Refs … — <reason>` lines when there are any (the statement is always the last
+line). A policy may replace the statement by
 exporting `renderNoSourceIssue({ reason })`, returning a non-empty string (30 s). The field also
 reaches `validatePullRequest` (with the trusted `mode`, so the policy can apply an interactive-only
 rule) and `pullRequestDefaults`.
@@ -327,15 +343,16 @@ rule) and `pullRequestDefaults`.
 
 ## Related issues
 
-- Closes #N — <reason>      (or "Refs #N"; "- None" when empty;
-                             "- No source issue — <reason>" for noSourceIssue)
+- Closes #N — <reason>      (or "Refs #N"; owner/name#N with `repository`; "- None" when empty;
+                             "- No source issue — <reason>" for noSourceIssue, rendered
+                             after any Refs lines)
 
 ## Details
 
 <details joined by blank lines>
 
 Workspace setup: <workspaceSetup>
-Agent: <agent>[ (<model>)] session <sessionId>
+Agent: <derived agent | unknown>[ (caller-claimed ...)] session <sessionId>
 Device: <os user>@<lowercased hostname>
 Worktree: <path after "/worktrees/", "main" for the main worktree, else the directory name>
 ```
@@ -357,8 +374,10 @@ with the repository's stack tooling instead.
   and `project`. It checks the head is pushed and current, writes the body to a mode 0600 temp file
   (removed afterwards) and runs `gh pr create --draft` with the labels, `--milestone` and
   `--project`. Returns `{ number, url, warnings }`.
-- `pr_update` (mutating): reads `gh pr view <pr> --json body,headRefName,baseRefName,state`,
-  rejects a pull request that is not `OPEN` or whose head is not the worktree branch, and validates
+- `pr_update` (mutating): reads `gh pr view <pr> --json body,headRefName,headRefOid,baseRefName,state`,
+  rejects a pull request that is not `OPEN` or whose head is neither the worktree branch nor the
+  worktree `HEAD` commit (an alias branch at the live head SHA is accepted and the live head name is
+  used), and validates
   against the live base (an explicit `base` must equal it). It renders, appends the live Shepherd
   Journal (a `<details><summary>Shepherd Journal</summary>` block, or a legacy `## Shepherd Journal`
   section to the next H2 or the end; examples in fenced code blocks are ignored), validates with

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vouchington-tooling",
-  "version": "0.45.0",
+  "version": "0.47.0",
   "description": "Vouchington CLI and extractable tooling libraries.",
   "homepage": "https://github.com/vouchington/vouchington-tooling/tree/main/packages/vouchington-tooling#readme",
   "bugs": {
@@ -71,11 +71,6 @@
       "default": "./dist/agent-blackboard/index.mjs"
     },
     "./mcp-server/bin": "./bin/vouchington-mcp.mjs",
-    "./session-friction": {
-      "types": "./dist/session-friction/index.d.mts",
-      "import": "./dist/session-friction/index.mjs",
-      "default": "./dist/session-friction/index.mjs"
-    },
     "./sql-ast": {
       "types": "./dist/sql-ast/index.d.mts",
       "import": "./dist/sql-ast/index.mjs",

package/dist/session-friction/ci-failures.d.mts

@@ -1,13 +0,0 @@
-import type { FrictionLogReadResult, JournalEntry } from './types.mts';
-import { type AuditRedactor } from './text.mts';
-export declare function isConformingCiFailureBlock(markdown: string): boolean;
-export declare function getConformingGroups(entries: Iterable<JournalEntry>, redact?: AuditRedactor, maxBytes?: number): string[];
-export declare function incompleteCiSection(markdownBlocks: string[]): string;
-export declare function buildCiFailuresSection(sessionId: string, journal: {
-    status: 'ok';
-    markdownBlocks: string[];
-    truncated: boolean;
-} | {
-    status: 'unreachable';
-    diagnostic: string;
-}, frictionStatus: FrictionLogReadResult['status'] | 'journal-only'): string;

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

@@ -1,2 +0,0 @@
-import type { FrictionEvent, FrictionObservation } from './types.mts';
-export declare function classifyFrictionObservation(observation: FrictionObservation): Omit<FrictionEvent, 'timestamp'> | null;

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;