vouchington-tooling 0.20.0 → 0.22.0

package/dist/retrospective-transcript/claude.mjs

@@ -1,4 +1,5 @@
-import { applyCommand, asNumber, asRecord, emptyFacts, parseLines, } from './shared.mjs';
+import { asRecord, emptyFacts, parseLines } from './shared.mjs';
+import { applyAssistantUsage, applyToolBlocks } from './claude-blocks.mjs';
 function hasPromptContent(content) {
     if (typeof content === 'string')
         return true;
@@ -27,39 +28,8 @@ export function computeClaude(lines) {
                 record.isMeta !== true &&
                 record.isCompactSummary !== true)
                 facts.userPrompts++;
-            if (record.type === 'assistant') {
-                if (!subagent)
-                    facts.assistantResponses++;
-                const usage = asRecord(message?.usage);
-                const totals = subagent ? facts.subagentTokens : facts.tokens;
-                totals.input += asNumber(usage?.input_tokens);
-                totals.output += asNumber(usage?.output_tokens);
-                totals.cacheRead += asNumber(usage?.cache_read_input_tokens);
-                totals.cacheCreation += asNumber(usage?.cache_creation_input_tokens);
-            }
-            const blocks = Array.isArray(message?.content) ? message.content : [];
-            for (const block of blocks) {
-                const value = asRecord(block);
-                if (!value)
-                    continue;
-                if (value.type === 'tool_use' || value.type === 'server_tool_use') {
-                    facts.toolCalls++;
-                    if (subagent)
-                        facts.subagentToolCalls++;
-                    if (value.name === 'advisor' && typeof value.id === 'string')
-                        advisorIds.add(value.id);
-                    if (value.name === 'Bash' || value.name === 'bash') {
-                        const command = asRecord(value.input)?.command;
-                        if (typeof command === 'string')
-                            applyCommand(command, facts);
-                    }
-                }
-                else if ((value.type === 'tool_result' && value.is_error === true) ||
-                    (typeof value.type === 'string' && value.type.endsWith('_tool_result_error')))
-                    facts.failedToolCalls++;
-                else if (value.type === 'advisor_tool_result' && typeof value.tool_use_id === 'string')
-                    advisorIds.add(value.tool_use_id);
-            }
+            applyAssistantUsage(record, message, subagent, facts);
+            applyToolBlocks(message, subagent, facts, advisorIds);
         }
     }
     facts.advisorCalls = advisorIds.size;

package/dist/retrospective-transcript/codex-payload.d.mts

@@ -0,0 +1,2 @@
+export declare function commands(payload: Record<string, unknown>): string[];
+export declare function hasFailedOutcome(value: unknown): boolean;

package/dist/retrospective-transcript/codex-payload.mjs

@@ -0,0 +1,51 @@
+import { customExecCommands } from './javascript-command.mjs';
+import { asRecord } from './shared.mjs';
+export function commands(payload) {
+    const raw = payload.type === 'function_call' ? payload.arguments : payload.input;
+    if (payload.type === 'local_shell_call') {
+        const input = asRecord(raw);
+        const value = asRecord(input?.action)?.command ?? input?.command;
+        if (typeof value === 'string')
+            return [value];
+        if (!Array.isArray(value))
+            return [];
+        return value.every((item) => typeof item === 'string') ? [value.join(' ')] : [];
+    }
+    const customExec = payload.type === 'custom_tool_call' && payload.name === 'exec';
+    if (!customExec && !['exec_command', 'bash', 'shell', 'Bash'].includes(String(payload.name)))
+        return [];
+    if (typeof raw !== 'string')
+        return [];
+    if (customExec)
+        return customExecCommands(raw);
+    try {
+        const value = asRecord(JSON.parse(raw));
+        const candidate = value?.cmd ?? value?.command;
+        return typeof candidate === 'string' ? [candidate] : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function hasFailedOutcome(value) {
+    if (Array.isArray(value))
+        return value.some(hasFailedOutcome);
+    const payload = asRecord(value);
+    if (!payload)
+        return false;
+    if (payload.type === 'input_text' && typeof payload.text === 'string') {
+        try {
+            return hasFailedOutcome(JSON.parse(payload.text));
+        }
+        catch {
+            return false;
+        }
+    }
+    if (payload.status === 'failed' || payload.status === 'error' || payload.is_error === true)
+        return true;
+    if ((typeof payload.exit_code === 'number' && payload.exit_code !== 0) ||
+        (typeof payload.exitCode === 'number' && payload.exitCode !== 0) ||
+        payload.success === false)
+        return true;
+    return [payload.output, payload.result, payload.metadata].some(hasFailedOutcome);
+}

package/dist/retrospective-transcript/codex-records.d.mts

@@ -0,0 +1,2 @@
+import { type ParsedLine, type TokenTotals, type TranscriptFacts } from './shared.mts';
+export declare function applyRecords(records: ParsedLine[], facts: TranscriptFacts, subagent: boolean, baseline?: TokenTotals): void;

package/dist/retrospective-transcript/codex-records.mjs

@@ -0,0 +1,95 @@
+import { CodexMessageCounter } from './codex-messages.mjs';
+import { commands, hasFailedOutcome } from './codex-payload.mjs';
+import { applyCommand, asNumber, asRecord, emptyTokens, } from './shared.mjs';
+function usage(record) {
+    const payload = asRecord(record.payload);
+    const totals = asRecord(asRecord(payload?.info)?.total_token_usage);
+    if (record.type !== 'event_msg' || payload?.type !== 'token_count' || !totals)
+        return undefined;
+    return {
+        input: asNumber(totals.input_tokens),
+        output: asNumber(totals.output_tokens),
+        cacheRead: asNumber(totals.cached_input_tokens),
+        cacheCreation: 0,
+    };
+}
+function isCall(payload) {
+    return (['function_call', 'custom_tool_call'].includes(String(payload.type)) ||
+        (typeof payload.type === 'string' && payload.type.endsWith('_call')));
+}
+function isCallOutcome(payload) {
+    return typeof payload.type === 'string' && payload.type.endsWith('_call_output');
+}
+function addDelta(current, previous, target) {
+    target.input += Math.max(0, current.input - previous.input);
+    target.output += Math.max(0, current.output - previous.output);
+    target.cacheRead += Math.max(0, current.cacheRead - previous.cacheRead);
+    return {
+        input: Math.max(current.input, previous.input),
+        output: Math.max(current.output, previous.output),
+        cacheRead: Math.max(current.cacheRead, previous.cacheRead),
+        cacheCreation: 0,
+    };
+}
+export function applyRecords(records, facts, subagent, baseline = emptyTokens()) {
+    let previous = baseline;
+    const calls = new Set();
+    const failed = new Set();
+    const messages = new CodexMessageCounter();
+    let anonymousFailures = 0;
+    let previousCompaction;
+    for (const record of records) {
+        const payload = asRecord(record.payload);
+        if (!subagent)
+            messages.add(record, payload);
+        const compaction = record.type === 'compacted'
+            ? 'top-level'
+            : record.type === 'event_msg' && payload?.type === 'context_compacted'
+                ? 'context-event'
+                : undefined;
+        if (compaction && previousCompaction !== undefined && previousCompaction !== compaction)
+            previousCompaction = undefined;
+        else if (compaction) {
+            facts.compactions++;
+            previousCompaction = compaction;
+        }
+        else
+            previousCompaction = undefined;
+        const totals = usage(record);
+        if (totals) {
+            previous = addDelta(totals, previous, subagent ? facts.subagentTokens : facts.tokens);
+        }
+        if (record.type !== 'response_item' || !payload)
+            continue;
+        const id = typeof payload.call_id === 'string'
+            ? payload.call_id
+            : typeof payload.id === 'string'
+                ? payload.id
+                : undefined;
+        if (isCall(payload)) {
+            if (!id || !calls.has(id)) {
+                facts.toolCalls++;
+                if (subagent)
+                    facts.subagentToolCalls++;
+                if (id)
+                    calls.add(id);
+                if (payload.name === 'advisor')
+                    facts.advisorCalls++;
+                for (const rawCommand of commands(payload))
+                    applyCommand(rawCommand, facts);
+            }
+        }
+        if ((isCall(payload) || isCallOutcome(payload)) && hasFailedOutcome(payload)) {
+            if (id)
+                failed.add(id);
+            else
+                anonymousFailures++;
+        }
+    }
+    if (!subagent) {
+        const [userPrompts, assistantResponses] = messages.totals();
+        facts.userPrompts += userPrompts;
+        facts.assistantResponses += assistantResponses;
+    }
+    facts.failedToolCalls += [...failed].filter((id) => calls.has(id)).length + anonymousFailures;
+}

package/dist/retrospective-transcript/codex.mjs

@@ -1,147 +1,5 @@
-import { applyCommand, asNumber, asRecord, emptyFacts, emptyTokens, parseLines, } from './shared.mjs';
-import { CodexMessageCounter } from './codex-messages.mjs';
-import { customExecCommands } from './javascript-command.mjs';
-function usage(record) {
-    const payload = asRecord(record.payload);
-    const totals = asRecord(asRecord(payload?.info)?.total_token_usage);
-    if (record.type !== 'event_msg' || payload?.type !== 'token_count' || !totals)
-        return undefined;
-    return {
-        input: asNumber(totals.input_tokens),
-        output: asNumber(totals.output_tokens),
-        cacheRead: asNumber(totals.cached_input_tokens),
-        cacheCreation: 0,
-    };
-}
-function commands(payload) {
-    const raw = payload.type === 'function_call' ? payload.arguments : payload.input;
-    if (payload.type === 'local_shell_call') {
-        const input = asRecord(raw);
-        const value = asRecord(input?.action)?.command ?? input?.command;
-        if (typeof value === 'string')
-            return [value];
-        if (!Array.isArray(value))
-            return [];
-        return value.every((item) => typeof item === 'string') ? [value.join(' ')] : [];
-    }
-    const customExec = payload.type === 'custom_tool_call' && payload.name === 'exec';
-    if (!customExec && !['exec_command', 'bash', 'shell', 'Bash'].includes(String(payload.name)))
-        return [];
-    if (typeof raw !== 'string')
-        return [];
-    if (customExec)
-        return customExecCommands(raw);
-    try {
-        const value = asRecord(JSON.parse(raw));
-        const candidate = value?.cmd ?? value?.command;
-        return typeof candidate === 'string' ? [candidate] : [];
-    }
-    catch {
-        return [];
-    }
-}
-function hasFailedOutcome(value) {
-    if (Array.isArray(value))
-        return value.some(hasFailedOutcome);
-    const payload = asRecord(value);
-    if (!payload)
-        return false;
-    if (payload.type === 'input_text' && typeof payload.text === 'string') {
-        try {
-            return hasFailedOutcome(JSON.parse(payload.text));
-        }
-        catch {
-            return false;
-        }
-    }
-    if (payload.status === 'failed' || payload.status === 'error' || payload.is_error === true)
-        return true;
-    if ((typeof payload.exit_code === 'number' && payload.exit_code !== 0) ||
-        (typeof payload.exitCode === 'number' && payload.exitCode !== 0) ||
-        payload.success === false)
-        return true;
-    return [payload.output, payload.result, payload.metadata].some(hasFailedOutcome);
-}
-function isCall(payload) {
-    return (['function_call', 'custom_tool_call'].includes(String(payload.type)) ||
-        (typeof payload.type === 'string' && payload.type.endsWith('_call')));
-}
-function isCallOutcome(payload) {
-    return typeof payload.type === 'string' && payload.type.endsWith('_call_output');
-}
-function addDelta(current, previous, target) {
-    target.input += Math.max(0, current.input - previous.input);
-    target.output += Math.max(0, current.output - previous.output);
-    target.cacheRead += Math.max(0, current.cacheRead - previous.cacheRead);
-    return {
-        input: Math.max(current.input, previous.input),
-        output: Math.max(current.output, previous.output),
-        cacheRead: Math.max(current.cacheRead, previous.cacheRead),
-        cacheCreation: 0,
-    };
-}
-function applyRecords(records, facts, subagent, baseline = emptyTokens()) {
-    let previous = baseline;
-    const calls = new Set();
-    const failed = new Set();
-    const messages = new CodexMessageCounter();
-    let anonymousFailures = 0;
-    let previousCompaction;
-    for (const record of records) {
-        const payload = asRecord(record.payload);
-        if (!subagent)
-            messages.add(record, payload);
-        const compaction = record.type === 'compacted'
-            ? 'top-level'
-            : record.type === 'event_msg' && payload?.type === 'context_compacted'
-                ? 'context-event'
-                : undefined;
-        if (compaction && previousCompaction !== undefined && previousCompaction !== compaction)
-            previousCompaction = undefined;
-        else if (compaction) {
-            facts.compactions++;
-            previousCompaction = compaction;
-        }
-        else
-            previousCompaction = undefined;
-        const totals = usage(record);
-        if (totals) {
-            previous = addDelta(totals, previous, subagent ? facts.subagentTokens : facts.tokens);
-        }
-        if (record.type !== 'response_item' || !payload)
-            continue;
-        const id = typeof payload.call_id === 'string'
-            ? payload.call_id
-            : typeof payload.id === 'string'
-                ? payload.id
-                : undefined;
-        if (isCall(payload)) {
-            if (!id || !calls.has(id)) {
-                facts.toolCalls++;
-                if (subagent)
-                    facts.subagentToolCalls++;
-                if (id)
-                    calls.add(id);
-                if (payload.name === 'advisor')
-                    facts.advisorCalls++;
-                for (const rawCommand of commands(payload))
-                    applyCommand(rawCommand, facts);
-            }
-        }
-        if ((isCall(payload) || isCallOutcome(payload)) && hasFailedOutcome(payload)) {
-            if (id)
-                failed.add(id);
-            else
-                anonymousFailures++;
-        }
-    }
-    if (!subagent) {
-        const [userPrompts, assistantResponses] = messages.totals();
-        facts.userPrompts += userPrompts;
-        facts.assistantResponses += assistantResponses;
-    }
-    facts.failedToolCalls += [...failed].filter((id) => calls.has(id)).length + anonymousFailures;
-}
+import { asRecord, emptyFacts, parseLines, } from './shared.mjs';
+import { applyRecords } from './codex-records.mjs';
 export function codexChildren(lines, ownerPath = '/root') {
     const direct = new Map();
     const base = ownerPath.replace(/\/$/, '');

package/dist/retrospective-transcript/index.d.mts

@@ -1,22 +1,9 @@
+import { type ResolveOptions } from './resolve-transcript-file.mts';
 import { type CodexSegment, type TranscriptFacts } from './shared.mts';
 export type { TokenTotals, TranscriptFacts } from './shared.mts';
 export { codexChildren, codexIdentity } from './codex.mts';
 export { formatTranscriptFacts, formatUnavailable } from './format.mts';
-export type ResolveOptions = {
-    sessionId?: string;
-    jsonlPath?: string;
-    projectsDir?: string;
-    codexSessionsDir?: string;
-    grokSessionsDir?: string;
-    cwd?: string;
-    env?: NodeJS.ProcessEnv;
-};
-type TranscriptResolution = {
-    path: string;
-    sessionId: string;
-} | {
-    error: string;
-};
-export declare function resolveTranscriptFile(options: ResolveOptions): TranscriptResolution;
+export type { ResolveOptions } from './resolve-transcript-file.mts';
+export { resolveTranscriptFile } from './resolve-transcript-file.mts';
 export declare function computeTranscriptFacts(lines: string[], subagents?: Array<string[] | CodexSegment>): TranscriptFacts;
 export declare function runRetrospectiveTranscript(options: ResolveOptions): Promise<string>;

package/dist/retrospective-transcript/index.mjs

@@ -1,61 +1,17 @@
-import { existsSync, globSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
-import { inspectHarnessEnvironment, selectHarnessSession, } from '../agent-harness-identity/index.mjs';
 import { codexChildren, codexIdentity, computeCodex } from './codex.mjs';
 import { segmentCodex } from './codex-segment.mjs';
 import { computeClaude } from './claude.mjs';
-import { formatTranscriptFacts, formatUnavailable, sessionLabel } from './format.mjs';
+import { formatTranscriptFacts, formatUnavailable } from './format.mjs';
+import { globFrom, resolveTranscriptFile, SESSION_ID, } from './resolve-transcript-file.mjs';
 import { emptyFacts, hasMalformedInteriorRecord, parseLines, } from './shared.mjs';
 export { codexChildren, codexIdentity } from './codex.mjs';
 export { formatTranscriptFacts, formatUnavailable } from './format.mjs';
-const SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export { resolveTranscriptFile } from './resolve-transcript-file.mjs';
 const MALFORMED_INTERIOR = 'malformed interior transcript record';
-function globFrom(root, pattern) {
-    return globSync(pattern, { cwd: root }).map((path) => join(root, path));
-}
-export function resolveTranscriptFile(options) {
-    if (options.sessionId && !SESSION_ID.test(options.sessionId))
-        return { error: 'invalid session id format' };
-    if (options.jsonlPath) {
-        const filename = basename(options.jsonlPath, '.jsonl');
-        const fileSessionId = filename.slice(-36);
-        return {
-            path: options.jsonlPath,
-            sessionId: options.sessionId?.toLowerCase() ??
-                (SESSION_ID.test(fileSessionId) ? fileSessionId.toLowerCase() : sessionLabel(filename)),
-        };
-    }
-    const env = options.env ?? process.env;
-    const sessionId = options.sessionId ??
-        selectHarnessSession(inspectHarnessEnvironment(env), ['codex', 'claude', 'cursor', 'grok'])
-            ?.sessionId;
-    if (!sessionId)
-        return {
-            error: 'no session id (pass --session-id or set CODEX_THREAD_ID, CLAUDE_CODE_SESSION_ID, CURSOR_SESSION_ID, or GROK_SESSION_ID)',
-        };
-    if (!SESSION_ID.test(sessionId))
-        return { error: 'invalid session id format' };
-    const normalizedSessionId = sessionId.toLowerCase();
-    const codex = options.codexSessionsDir ?? join(env.CODEX_HOME || join(homedir(), '.codex'), 'sessions');
-    const claude = options.projectsDir ?? join(env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'), 'projects');
-    const grokHome = env.GROK_HOME || join(homedir(), '.grok');
-    const grok = options.grokSessionsDir ?? join(grokHome, 'sessions');
-    const encodedCwd = encodeURIComponent(options.cwd ?? process.cwd());
-    const grokExact = join(grok, encodedCwd, normalizedSessionId, 'updates.jsonl');
-    const grokPaths = existsSync(grokExact)
-        ? [grokExact]
-        : globFrom(grok, `*/${normalizedSessionId}/updates.jsonl`);
-    const codexPaths = globFrom(codex, `**/rollout-*-${normalizedSessionId}.jsonl`);
-    const claudePaths = globFrom(claude, `*/${normalizedSessionId}.jsonl`);
-    const paths = [...grokPaths, ...codexPaths, ...claudePaths].sort();
-    if (paths.length > 1)
-        return { error: `multiple transcripts found for session ${normalizedSessionId}` };
-    return paths[0]
-        ? { path: paths[0], sessionId: normalizedSessionId }
-        : { error: `no transcript found for session ${normalizedSessionId}` };
-}
 function schema(lines) {
     const records = parseLines(lines);
     const kinds = new Set(records

package/dist/retrospective-transcript/resolve-transcript-file.d.mts

@@ -0,0 +1,19 @@
+export type ResolveOptions = {
+    sessionId?: string;
+    jsonlPath?: string;
+    projectsDir?: string;
+    codexSessionsDir?: string;
+    grokSessionsDir?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+};
+export declare const SESSION_ID: RegExp;
+type TranscriptResolution = {
+    path: string;
+    sessionId: string;
+} | {
+    error: string;
+};
+export declare function globFrom(root: string, pattern: string): string[];
+export declare function resolveTranscriptFile(options: ResolveOptions): TranscriptResolution;
+export {};

package/dist/retrospective-transcript/resolve-transcript-file.mjs

@@ -0,0 +1,50 @@
+import { existsSync, globSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { inspectHarnessEnvironment, selectHarnessSession, } from '../agent-harness-identity/index.mjs';
+import { sessionLabel } from './format.mjs';
+export const SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function globFrom(root, pattern) {
+    return globSync(pattern, { cwd: root }).map((path) => join(root, path));
+}
+export function resolveTranscriptFile(options) {
+    if (options.sessionId && !SESSION_ID.test(options.sessionId))
+        return { error: 'invalid session id format' };
+    if (options.jsonlPath) {
+        const filename = basename(options.jsonlPath, '.jsonl');
+        const fileSessionId = filename.slice(-36);
+        return {
+            path: options.jsonlPath,
+            sessionId: options.sessionId?.toLowerCase() ??
+                (SESSION_ID.test(fileSessionId) ? fileSessionId.toLowerCase() : sessionLabel(filename)),
+        };
+    }
+    const env = options.env ?? process.env;
+    const sessionId = options.sessionId ??
+        selectHarnessSession(inspectHarnessEnvironment(env), ['codex', 'claude', 'cursor', 'grok'])
+            ?.sessionId;
+    if (!sessionId)
+        return {
+            error: 'no session id (pass --session-id or set CODEX_THREAD_ID, CLAUDE_CODE_SESSION_ID, CURSOR_SESSION_ID, or GROK_SESSION_ID)',
+        };
+    if (!SESSION_ID.test(sessionId))
+        return { error: 'invalid session id format' };
+    const normalizedSessionId = sessionId.toLowerCase();
+    const codex = options.codexSessionsDir ?? join(env.CODEX_HOME || join(homedir(), '.codex'), 'sessions');
+    const claude = options.projectsDir ?? join(env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'), 'projects');
+    const grokHome = env.GROK_HOME || join(homedir(), '.grok');
+    const grok = options.grokSessionsDir ?? join(grokHome, 'sessions');
+    const encodedCwd = encodeURIComponent(options.cwd ?? process.cwd());
+    const grokExact = join(grok, encodedCwd, normalizedSessionId, 'updates.jsonl');
+    const grokPaths = existsSync(grokExact)
+        ? [grokExact]
+        : globFrom(grok, `*/${normalizedSessionId}/updates.jsonl`);
+    const codexPaths = globFrom(codex, `**/rollout-*-${normalizedSessionId}.jsonl`);
+    const claudePaths = globFrom(claude, `*/${normalizedSessionId}.jsonl`);
+    const paths = [...grokPaths, ...codexPaths, ...claudePaths].sort();
+    if (paths.length > 1)
+        return { error: `multiple transcripts found for session ${normalizedSessionId}` };
+    return paths[0]
+        ? { path: paths[0], sessionId: normalizedSessionId }
+        : { error: `no transcript found for session ${normalizedSessionId}` };
+}

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,94 @@
+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/log-file.d.mts

@@ -0,0 +1,7 @@
+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): string;
+export declare function atEventLimit(content: string, limit: number): boolean;
+export declare function writeAll(descriptor: number, value: string): void;