@guilz-dev/belay 0.9.1 → 0.9.3

package/dist/core/audit-summary.js

@@ -1,4 +1,4 @@
-import { filterAuditRecords, inferWouldBlock, isApprovalRecorded, isGateRecord, parseTimestamp, recordStringField, } from './audit-query.js';
+import { auditToolInvocationCorrelationId, filterAuditRecords, inferWouldBlock, isApprovalRecorded, isGateRecord, parseTimestamp, recordStringField, } from './audit-query.js';
 export const DEFAULT_SILENT_PASS_THRESHOLD = 0.5;
 export const MIN_GATE_EVENTS_FOR_FENCE_DRIFT = 20;
 function isTier0Reason(reason) {
@@ -38,6 +38,7 @@ function isGateEventRecord(record) {
 export function summarizeAuditVisibility(records, filter = {}, options = {}) {
     const filtered = filterAuditRecords(records, filter);
     const gateRecords = filtered.filter(isGateEventRecord);
+    const allGateRecords = records.filter(isGateEventRecord);
     const recentAskLimit = options.recentAskLimit ?? 10;
     let askCount = 0;
     let enforceAskCount = 0;
@@ -46,6 +47,23 @@ export function summarizeAuditVisibility(records, filter = {}, options = {}) {
     let flagCount = 0;
     let allowCount = 0;
     const recentAsks = [];
+    const allowedByInvocation = new Map();
+    const recentHostDenials = [];
+    let unrecognizedHostFailureCount = 0;
+    const matchedHostDenials = new Set();
+    for (const record of allGateRecords) {
+        const invocationId = auditToolInvocationCorrelationId(record);
+        if (invocationId && !inferWouldBlock(record) && record.permission === 'allow') {
+            const existing = allowedByInvocation.get(invocationId);
+            const recordMs = parseTimestamp(record.timestamp) ?? Number.NEGATIVE_INFINITY;
+            const existingMs = existing
+                ? (parseTimestamp(existing.timestamp) ?? Number.NEGATIVE_INFINITY)
+                : Number.NEGATIVE_INFINITY;
+            if (!existing || recordMs >= existingMs) {
+                allowedByInvocation.set(invocationId, record);
+            }
+        }
+    }
     for (const record of gateRecords) {
         if (inferWouldBlock(record)) {
             askCount += 1;
@@ -73,11 +91,47 @@ export function summarizeAuditVisibility(records, filter = {}, options = {}) {
             allowCount += 1;
         }
     }
+    for (const record of filtered) {
+        if (record.event !== 'postToolUseFailure') {
+            continue;
+        }
+        if (record.failureType !== 'permission_denied') {
+            unrecognizedHostFailureCount += 1;
+            continue;
+        }
+        const invocationId = auditToolInvocationCorrelationId(record);
+        const gate = invocationId ? allowedByInvocation.get(invocationId) : undefined;
+        if (!gate) {
+            continue;
+        }
+        const gateMs = parseTimestamp(gate.timestamp);
+        const failureMs = parseTimestamp(record.timestamp);
+        if (gateMs !== null && failureMs !== null && failureMs < gateMs) {
+            continue;
+        }
+        if (invocationId && matchedHostDenials.has(invocationId)) {
+            continue;
+        }
+        if (invocationId) {
+            matchedHostDenials.add(invocationId);
+        }
+        recentHostDenials.push({
+            gateTimestamp: gate.timestamp,
+            failureTimestamp: record.timestamp,
+            summary: typeof gate.summary === 'string' ? gate.summary : '',
+            errorMessage: typeof record.errorMessage === 'string' ? record.errorMessage : '',
+        });
+    }
     recentAsks.sort((left, right) => {
         const leftMs = parseTimestamp(left.timestamp) ?? 0;
         const rightMs = parseTimestamp(right.timestamp) ?? 0;
         return rightMs - leftMs;
     });
+    recentHostDenials.sort((left, right) => {
+        const leftMs = parseTimestamp(left.failureTimestamp) ?? 0;
+        const rightMs = parseTimestamp(right.failureTimestamp) ?? 0;
+        return rightMs - leftMs;
+    });
     const gateEvents = gateRecords.length;
     const silentPassRate = gateEvents > 0 ? (allowCount + flagCount) / gateEvents : 0;
     return {
@@ -90,6 +144,9 @@ export function summarizeAuditVisibility(records, filter = {}, options = {}) {
         allowCount,
         silentPassRate,
         recentAsks: recentAsks.slice(0, recentAskLimit),
+        hostDeniedAfterAllowCount: recentHostDenials.length,
+        recentHostDenials: recentHostDenials.slice(0, recentAskLimit),
+        unrecognizedHostFailureCount,
     };
 }
 export function detectFenceDrift(summary, options = {}) {

package/dist/core/audit-types.d.ts

@@ -12,6 +12,10 @@ export interface AuditRecord {
     fingerprint?: string;
     summary?: string;
     approvalId?: string;
+    toolInvocationCorrelationId?: string;
+    toolName?: string;
+    failureType?: string;
+    errorMessage?: string;
     wouldBlock?: boolean;
     judgeFallbackReason?: string;
     permission?: string;

package/dist/core/effect-ir/shell-lower.js

@@ -1,11 +1,13 @@
 import { lstatSync, realpathSync } from 'node:fs';
 import path from 'node:path';
 import { inspectGitResourceIdentity } from '../git-resource-identity.js';
-import { isFdDuplication, isRedirectOperator, tokenizeShell } from '../shell-tokenizer.js';
+import { canonicalPath, pathWithinRoot } from '../path-utils.js';
+import { isFdDuplication, isRedirectOperator, lexShell, tokenizeShell, } from '../shell-tokenizer.js';
+import { decodeDockerComposeRun as decodeStructuredDockerComposeRun } from '../verdict/docker-compose-run.js';
 import { decodeEgressEffects } from '../verdict/egress-classify.js';
 import { decodeGitEffects } from '../verdict/git-classifier.js';
 import { resolveLauncherRecipe } from '../verdict/launcher-resolve.js';
-import { extractRecursiveScript, isCommandInspection, isDynamicRecursiveEvaluation, parseSegment, redactCommand, segmentOpacity, splitStructuralShellSegments, structuralSubstitutionInners, } from '../verdict/parser.js';
+import { decodeRecursiveInvocationTokens, isCommandInspection, parseSegment, redactCommand, segmentOpacity, splitStructuralShellSegments, structuralSubstitutionInners, } from '../verdict/parser.js';
 import { joinEffectOpacity } from './normalize.js';
 import { classifyPackageAcquisitionSpec, innerRecipeFromPeel, peelPackageExecArgv, resolveLocalBin, } from './package-exec.js';
 import { buildShellEffectPlan, } from './shell-build.js';
@@ -126,15 +128,29 @@ function joinNestedOpacity(outer, nested) {
 }
 function lowerSegment(command, context) {
     const commandRedacted = redactCommand(command);
-    const rawTokens = tokenizeShell(command);
+    const lexed = lexShell(command);
+    const rawTokens = lexed.tokens.map((token) => token.value);
     const environment = extractEnvironment(rawTokens, context.env);
     const env = environment.env;
     const parsed = parseSegment(command);
-    const tokens = stripRedirects(environment.commandTokens ?? parsed.tokens).map((token) => expandKnownVariables(token, env));
+    const parsedTokens = environment.commandTokens ?? parsed.tokens;
+    const tokens = stripRedirects(parsedTokens.length === 0 &&
+        rawTokens.length > 0 &&
+        rawTokens.every((token) => ENV_PREFIX_PATTERN.test(token))
+        ? rawTokens
+        : parsedTokens).map((token) => expandKnownVariables(token, env));
+    const decoderTokens = alignStructuredTokens(stripStructuredRedirects(lexed.tokens), stripRedirects(parsedTokens));
     const head = path.basename(tokens[0] ?? parsed.head);
     let opacity = segmentOpacity(command);
     const signals = new Set();
     const requirements = [];
+    if (!lexed.complete) {
+        requirements.push(requirement('indeterminate', 'indeterminate', { kind: 'unknown' }, commandRedacted, [
+            'shell.grammar_incomplete',
+        ]));
+        signals.add('shell.grammar_incomplete');
+        opacity = joinEffectOpacity(opacity, 'unparseable');
+    }
     addRedirectEffects(requirements, rawTokens, env, context, commandRedacted);
     addSubstitutionEffects(requirements, command, context, commandRedacted, signals);
     if (environment.malformed) {
@@ -150,7 +166,7 @@ function lowerSegment(command, context) {
         signals.add('shell.xargs_stdin_dynamic');
         opacity = joinEffectOpacity(opacity, 'opaque');
     }
-    if (context.depth >= MAX_LOWER_DEPTH) {
+    if (context.depth > MAX_LOWER_DEPTH) {
         requirements.push(requirement('indeterminate', 'indeterminate', { kind: 'unknown' }, commandRedacted, [
             'shell.lower_depth_exceeded',
         ]));
@@ -185,31 +201,69 @@ function lowerSegment(command, context) {
         }
         return shellSegment(commandRedacted, head, requirements, opacity, signals);
     }
-    const recursiveScript = extractRecursiveScript(tokens);
-    if (recursiveScript && opacity !== 'opaque' && opacity !== 'unparseable') {
-        const dynamicEvaluation = isDynamicRecursiveEvaluation(tokens);
-        requirements.push(processRequirement(head || 'sh', 'spawn', commandRedacted, [
+    const recursive = decodeRecursiveInvocationTokens(decoderTokens);
+    if (recursive.kind === 'static' && opacity !== 'opaque' && opacity !== 'unparseable') {
+        requirements.push(processRequirement(recursive.interpreter, 'spawn', commandRedacted, [
             'shell.recursive_wrapper',
-            ...(dynamicEvaluation ? ['dynamic_shell_evaluation'] : []),
+            'dynamic_shell_evaluation',
         ]));
-        const nested = lowerTopLevelSegments(recursiveScript, {
-            ...context,
-            command: recursiveScript,
-            env,
-            depth: context.depth + 1,
-        });
-        for (const nestedSegment of nested) {
-            requirements.push(...nestedSegment.requirements.map((entry) => withInnerProvenance(entry, recursiveScript, head, commandRedacted)));
-            for (const signal of nestedSegment.signals) {
-                signals.add(signal);
+        if (recursive.script !== '') {
+            const nested = lowerTopLevelSegments(recursive.script, {
+                ...context,
+                command: recursive.script,
+                env,
+                depth: context.depth + 1,
+            });
+            for (const nestedSegment of nested) {
+                requirements.push(...nestedSegment.requirements.map((entry) => withInnerProvenance(entry, recursive.script, head, commandRedacted)));
+                for (const signal of nestedSegment.signals)
+                    signals.add(signal);
             }
         }
         signals.add('shell.recursive_wrapper');
-        if (dynamicEvaluation) {
-            signals.add('dynamic_shell_evaluation');
+        signals.add('dynamic_shell_evaluation');
+        return shellSegment(commandRedacted, head, requirements, 'recursive', signals);
+    }
+    if (recursive.kind === 'dynamic' || recursive.kind === 'indeterminate') {
+        const recursiveSignals = [
+            recursive.signal,
+            ...(recursive.kind === 'dynamic' ? ['dynamic_shell_evaluation'] : []),
+        ];
+        requirements.push(processRequirement(recursive.interpreter, 'spawn', commandRedacted, recursiveSignals), requirement('indeterminate', 'indeterminate', { kind: 'unknown' }, commandRedacted, [
+            ...recursiveSignals,
+        ]));
+        for (const signal of recursiveSignals)
+            signals.add(signal);
+        return shellSegment(commandRedacted, head, requirements, joinEffectOpacity(opacity, 'opaque'), signals);
+    }
+    const compose = decodeStructuredDockerComposeRun(decoderTokens);
+    if (compose.kind === 'recursive' && opacity !== 'opaque' && opacity !== 'unparseable') {
+        requirements.push(processRequirement(head, 'spawn', commandRedacted, ['process.docker_compose_run']));
+        if (compose.script !== '') {
+            const nested = lowerTopLevelSegments(compose.script, {
+                ...context,
+                command: compose.script,
+                env,
+                depth: context.depth + 1,
+            });
+            for (const nestedSegment of nested) {
+                requirements.push(...nestedSegment.requirements.map((entry) => withInnerProvenance(entry, compose.script, head, commandRedacted)));
+                for (const signal of nestedSegment.signals)
+                    signals.add(signal);
+                opacity = joinNestedOpacity(opacity, nestedSegment);
+            }
         }
+        signals.add('process.docker_compose_run');
         return shellSegment(commandRedacted, head, requirements, 'recursive', signals);
     }
+    if (compose.kind === 'dynamic' || compose.kind === 'indeterminate') {
+        requirements.push(processRequirement(head, 'spawn', commandRedacted, ['process.docker_compose_run']), requirement('indeterminate', 'indeterminate', { kind: 'unknown' }, commandRedacted, [
+            compose.signal,
+        ]));
+        signals.add('process.docker_compose_run');
+        signals.add(compose.signal);
+        return shellSegment(commandRedacted, head, requirements, joinEffectOpacity(opacity, 'opaque'), signals);
+    }
     const launcher = resolveLauncherRecipe({
         tokens,
         cwd: context.cwd,
@@ -381,6 +435,101 @@ function railsReadOnlySubcommand(args) {
     }
     return RAILS_READ_ONLY_SUBCOMMANDS.has(subcommand);
 }
+function isRubyTestScript(scriptPath) {
+    const base = path.basename(scriptPath);
+    return base.endsWith('_test.rb') || base.endsWith('_spec.rb');
+}
+function parseRubyTestInvocation(args) {
+    const includePaths = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index] ?? '';
+        if (arg === '-e' || arg === '-r') {
+            return null;
+        }
+        if (arg === '-I') {
+            const includePath = args[index + 1];
+            if (!includePath) {
+                return null;
+            }
+            includePaths.push(includePath);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('-I') && arg.length > 2) {
+            includePaths.push(arg.slice(2));
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            if (arg === '-n') {
+                if (!args[index + 1]) {
+                    return null;
+                }
+                index += 1;
+                continue;
+            }
+            if (arg.startsWith('-n')) {
+                continue;
+            }
+            return null;
+        }
+        if (isRubyTestScript(arg)) {
+            return { includePaths, scriptPath: arg };
+        }
+        return null;
+    }
+    return null;
+}
+function isRubocopMutating(args) {
+    return args.some((arg) => arg === '-A' ||
+        arg === '-a' ||
+        arg === '--auto-correct' ||
+        arg === '--autocorrect' ||
+        arg.startsWith('--auto-correct-all') ||
+        arg.startsWith('--autocorrect-all'));
+}
+function decodeBundleExecInner(innerHead, innerArgs, segment) {
+    const innerBase = executableBaseName(innerHead);
+    if (innerBase === 'rubocop') {
+        const mutating = isRubocopMutating(innerArgs);
+        return [
+            processRequirement(innerHead, mutating ? 'spawn' : 'inspect', segment, mutating ? ['process.linter.mutating'] : ['process.inspect.linter']),
+        ];
+    }
+    if (innerBase === 'rspec') {
+        const targetArgs = innerArgs.filter((arg) => !arg.startsWith('-'));
+        if (targetArgs.length === 0) {
+            return null;
+        }
+        return [processRequirement(innerHead, 'spawn', segment, ['process.test_runner.rspec'])];
+    }
+    return null;
+}
+function decodeRuby(args, cwd, repoRoot, segment) {
+    const parsed = parseRubyTestInvocation(args);
+    if (!parsed) {
+        return unsupportedProcess('ruby', segment, 'process.ruby_grammar_incomplete');
+    }
+    const scriptPath = resolvePathOperand(parsed.scriptPath, cwd);
+    if (!pathWithinRoot(canonicalPath(repoRoot), canonicalPath(scriptPath))) {
+        return unsupportedProcess('ruby', segment, 'process.ruby_outside_repo');
+    }
+    for (const includePath of parsed.includePaths) {
+        const resolvedInclude = resolvePathOperand(includePath, cwd);
+        if (!pathWithinRoot(canonicalPath(repoRoot), canonicalPath(resolvedInclude))) {
+            return unsupportedProcess('ruby', segment, 'process.ruby_outside_repo');
+        }
+    }
+    const lowered = [
+        processRequirement('ruby', 'spawn', segment, ['process.test_runner.minitest']),
+        requirement('fs.read', 'fs.read', { kind: 'path', path: scriptPath }, segment, [
+            'ruby.minitest_script_read',
+        ]),
+    ];
+    for (const includePath of parsed.includePaths) {
+        lowered.push(requirement('fs.read', 'fs.read', { kind: 'path', path: resolvePathOperand(includePath, cwd) }, segment, ['ruby.minitest_load_path_read']));
+    }
+    return lowered;
+}
 function decodeRuntimeMetadataProcess(head, args, segment) {
     if (head === 'bundle') {
         if (args.length === 1 && isMetadataOnlyArgv(args)) {
@@ -402,6 +551,10 @@ function decodeRuntimeMetadataProcess(head, args, segment) {
                     ]),
                 ];
             }
+            const bundleExecInner = decodeBundleExecInner(innerHead, innerArgs, segment);
+            if (bundleExecInner) {
+                return bundleExecInner;
+            }
         }
         return null;
     }
@@ -417,9 +570,75 @@ function decodeRuntimeMetadataProcess(head, args, segment) {
     }
     return null;
 }
+function decodeSetBuiltin(args) {
+    let index = 0;
+    while (index < args.length) {
+        const arg = args[index] ?? '';
+        if (arg === '--') {
+            index += 1;
+            continue;
+        }
+        if (arg === '-o' || arg === '+o') {
+            if (!args[index + 1]) {
+                return false;
+            }
+            index += 2;
+            continue;
+        }
+        if (/^[-+][A-Za-z0-9]+$/.test(arg)) {
+            index += 1;
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+function decodeShellControlBuiltin(head, args) {
+    if (head === 'set') {
+        return decodeSetBuiltin(args) ? [] : null;
+    }
+    if (head === 'wait') {
+        if (args.length === 0 || args.every((arg) => /^\d+$/.test(arg))) {
+            return [];
+        }
+        return null;
+    }
+    if (head === 'exit') {
+        if (args.length === 0 || (args.length === 1 && /^-?\d+$/.test(args[0] ?? ''))) {
+            return [];
+        }
+        return null;
+    }
+    return null;
+}
+function decodeDockerComposeRun(head, args, segment) {
+    let composeArgs = null;
+    let command = head;
+    if (head === 'docker-compose') {
+        composeArgs = args;
+    }
+    else if (head === 'docker' && args[0] === 'compose') {
+        composeArgs = args.slice(1);
+        command = 'docker';
+    }
+    if (!composeArgs) {
+        return null;
+    }
+    if (composeArgs.includes('run')) {
+        return [processRequirement(command, 'spawn', segment, ['process.docker_compose_run'])];
+    }
+    return unsupportedProcess(command, segment, 'process.docker_compose_grammar_incomplete');
+}
 function decodeProcessOrFilesystem(params) {
     const { tokens, head, env, cwd, repoRoot, segment } = params;
     const args = tokens.slice(1);
+    if (tokens.length > 0 && tokens.every((token) => ENV_PREFIX_PATTERN.test(token))) {
+        return [];
+    }
+    const shellControl = decodeShellControlBuiltin(head, args);
+    if (shellControl) {
+        return shellControl;
+    }
     if (isCommandInspection(tokens)) {
         return [processRequirement(head, 'inspect', segment, ['process.inspect.command_lookup'])];
     }
@@ -500,6 +719,19 @@ function decodeProcessOrFilesystem(params) {
     if (runtimeMetadata) {
         return runtimeMetadata;
     }
+    if (head === 'ruby') {
+        return decodeRuby(args, cwd, repoRoot, segment);
+    }
+    if (head === 'rubocop' || head === 'rspec') {
+        const decoded = decodeBundleExecInner(head, args, segment);
+        if (decoded) {
+            return decoded;
+        }
+    }
+    const dockerCompose = decodeDockerComposeRun(head, args, segment);
+    if (dockerCompose) {
+        return dockerCompose;
+    }
     if ((head === 'npm' || head === 'pnpm') && args.length === 1 && isMetadataOnlyArgv(args)) {
         return [processRequirement(head, 'inspect', segment, ['process.inspect.package_manager'])];
     }
@@ -1134,15 +1366,39 @@ function stripRedirects(tokens) {
             stripped.push(token);
             continue;
         }
-        if (token.includes('>') || token.includes('<')) {
-            const inline = token.replace(/^\d*(?:>>?|<<?|<>|>\|)/, '');
-            if (!inline) {
-                index += 1;
-            }
+        index += 1;
+    }
+    return stripped;
+}
+function stripStructuredRedirects(tokens) {
+    const stripped = [];
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (!token)
+            continue;
+        if (isFdDuplication(token.value)) {
+            continue;
         }
+        if (!isRedirectOperator(token.value)) {
+            stripped.push(token);
+            continue;
+        }
+        index += 1;
     }
     return stripped;
 }
+function alignStructuredTokens(tokens, values) {
+    if (values.length === 0)
+        return [];
+    for (let start = tokens.length - values.length; start >= 0; start -= 1) {
+        const candidate = tokens.slice(start);
+        if (candidate.length === values.length &&
+            candidate.every((token, index) => token.value === values[index])) {
+            return candidate;
+        }
+    }
+    return [];
+}
 function shellSegment(commandRedacted, segmentHead, requirements, opacity, signals) {
     const normalizedRequirements = requirements.flatMap((entry) => {
         const dynamicSignal = dynamicResourceSignal(entry.resource);

package/dist/core/replay-scrub.d.ts

@@ -1,5 +1,6 @@
 import type { GatedActionKind } from './gate-contract.js';
 import type { ScrubOptions } from './types.js';
+export declare function redactToolInvocationId(value: unknown, rawToolUseId?: string): unknown;
 /** Subagent fingerprint input — must match classify-subagent `fingerprintSource`. */
 export declare function subagentFingerprintSource(payload: Record<string, unknown>, scrubOptions: ScrubOptions): unknown;
 /**

package/dist/core/replay-scrub.js

@@ -1,4 +1,22 @@
 import { scrubValue } from './scrub.js';
+export function redactToolInvocationId(value, rawToolUseId) {
+    if (typeof value === 'string') {
+        return rawToolUseId ? value.replaceAll(rawToolUseId, '<tool-use-id>') : value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => redactToolInvocationId(item, rawToolUseId));
+    }
+    if (value && typeof value === 'object') {
+        const result = {};
+        for (const [key, child] of Object.entries(value)) {
+            if (key !== 'tool_use_id') {
+                result[key] = redactToolInvocationId(child, rawToolUseId);
+            }
+        }
+        return result;
+    }
+    return value;
+}
 /** Subagent fingerprint input — must match classify-subagent `fingerprintSource`. */
 export function subagentFingerprintSource(payload, scrubOptions) {
     const toolInput = payload.tool_input;
@@ -30,14 +48,15 @@ export function fingerprintReplayPayload(kind, payload, scrubOptions) {
     if (!payload) {
         return undefined;
     }
+    const replayPayload = redactToolInvocationId(payload, typeof payload.tool_use_id === 'string' ? payload.tool_use_id : undefined);
     if (kind === 'tool') {
-        const toolInput = payload.tool_input;
+        const toolInput = replayPayload.tool_input;
         if (toolInput && typeof toolInput === 'object') {
             return scrubValue(toolInput, scrubOptions);
         }
     }
     if (kind === 'subagent') {
-        return subagentFingerprintSource(payload, scrubOptions);
+        return subagentFingerprintSource(replayPayload, scrubOptions);
     }
-    return scrubValue(payload, scrubOptions);
+    return scrubValue(replayPayload, scrubOptions);
 }

package/dist/core/shell-tokenizer.d.ts

@@ -1,5 +1,33 @@
 export declare function isRedirectOperator(token: string): boolean;
 export declare function isFdDuplication(token: string): boolean;
+export type ShellQuoteMode = 'unquoted' | 'single' | 'double';
+export interface ShellWordPart {
+    value: string;
+    raw: string;
+    start: number;
+    end: number;
+    quote: ShellQuoteMode;
+    hasExpansion: boolean;
+}
+export type ShellToken = {
+    kind: 'word';
+    value: string;
+    raw: string;
+    start: number;
+    end: number;
+    parts: ShellWordPart[];
+} | {
+    kind: 'operator';
+    value: string;
+    raw: string;
+    start: number;
+    end: number;
+};
+export interface ShellLexResult {
+    tokens: ShellToken[];
+    complete: boolean;
+}
+export declare function lexShell(input: string): ShellLexResult;
 export declare function tokenizeShell(input: string): string[];
 export declare function normalizeShellCommand(command: string, repoRoot: string, normalizeToken: (t: string, r: string) => string): string;
 export declare function splitTopLevelSegments(tokens: string[]): string[][];