salmon-loop 0.2.3

package/dist/core/llm/phase-router.js

@@ -0,0 +1,55 @@
+import { Phase } from '../types/runtime.js';
+export function createPhaseRoutingLlm(params) {
+    const { defaultLlm, phaseLlms } = params;
+    const resolve = (phase) => {
+        if (!phase)
+            return defaultLlm;
+        return phaseLlms[phase] ?? defaultLlm;
+    };
+    const hasAnyStreaming = typeof defaultLlm.chatStream === 'function' ||
+        Object.values(phaseLlms).some((llm) => typeof llm?.chatStream === 'function');
+    const routed = {
+        chat(messages, options) {
+            return resolve(options?.phase).chat(messages, options);
+        },
+        getCapabilities() {
+            const base = defaultLlm.getCapabilities?.() ?? {};
+            const hasToolCalling = Object.values(phaseLlms).some((llm) => llm?.getCapabilities?.().toolCalling);
+            const hasStreaming = Object.values(phaseLlms).some((llm) => llm?.getCapabilities?.().streaming);
+            const hasJsonMode = Object.values(phaseLlms).some((llm) => llm?.getCapabilities?.().responseFormatJsonObject);
+            return {
+                toolCalling: base.toolCalling || hasToolCalling,
+                streaming: base.streaming || hasStreaming,
+                responseFormatJsonObject: base.responseFormatJsonObject || hasJsonMode,
+            };
+        },
+        createPlan(context, instruction, lastError, signal) {
+            return resolve(Phase.PLAN).createPlan(context, instruction, lastError, signal);
+        },
+        createPatch(context, plan, lastError, signal) {
+            return resolve(Phase.PATCH).createPatch(context, plan, lastError, signal);
+        },
+    };
+    if (hasAnyStreaming) {
+        routed.chatStream = async function* (messages, options) {
+            const selected = resolve(options?.phase);
+            if (selected.chatStream) {
+                yield* selected.chatStream(messages, options);
+                return;
+            }
+            const fallback = await selected.chat(messages, options);
+            if (fallback.content) {
+                yield { role: 'assistant', source: 'synthesized', contentDelta: fallback.content };
+            }
+            if (Array.isArray(fallback.tool_calls) && fallback.tool_calls.length > 0) {
+                yield { role: 'assistant', source: 'synthesized', tool_calls: fallback.tool_calls };
+            }
+            yield { role: 'assistant', source: 'synthesized', done: true, finishReason: 'stop' };
+        };
+    }
+    if (defaultLlm.getModelId) {
+        routed.getModelId = () => defaultLlm.getModelId();
+    }
+    return routed;
+}
+//# sourceMappingURL=phase-router.js.map

package/dist/core/llm/redact.js

@@ -0,0 +1,37 @@
+const SECRET_KEY_REGEX = /(api[-_]?key|authorization|token|secret|password|cookie)/i;
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function truncate(value, max = 500) {
+    if (value.length <= max)
+        return value;
+    return value.slice(0, max) + '...';
+}
+export function redactValue(value) {
+    if (typeof value === 'string')
+        return truncate(value, 500);
+    if (typeof value === 'number' || typeof value === 'boolean' || value === null)
+        return value;
+    if (Array.isArray(value))
+        return value.map(redactValue);
+    if (isRecord(value)) {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            if (SECRET_KEY_REGEX.test(k)) {
+                out[k] = '[REDACTED]';
+            }
+            else {
+                out[k] = redactValue(v);
+            }
+        }
+        return out;
+    }
+    return '[Unserializable]';
+}
+export function redactJsonString(raw) {
+    return truncate(raw, 500);
+}
+export function redactErrorMessage(raw) {
+    return truncate(raw, 500);
+}
+//# sourceMappingURL=redact.js.map

package/dist/core/llm/registry.js

@@ -0,0 +1,81 @@
+import { AiSdkLLM } from './ai-sdk.js';
+import { StubLLM } from './openai.js';
+function keyToString(key) {
+    return `${key.providerType}::${key.clientPackage || ''}`;
+}
+export class LlmAdapterRegistry {
+    map = new Map();
+    register(key, factory) {
+        this.map.set(keyToString(key), factory);
+    }
+    resolve(key) {
+        return this.map.get(keyToString(key));
+    }
+    isClientPackageAllowed(providerType, clientPackage) {
+        for (const k of this.map.keys()) {
+            const [t, pkg] = k.split('::');
+            if (t === providerType && pkg === clientPackage)
+                return true;
+        }
+        return false;
+    }
+}
+export function createDefaultLlmRegistry() {
+    const reg = new LlmAdapterRegistry();
+    const buildAiSdk = (clientPackage) => {
+        return (resolved, options) => {
+            const warnings = [];
+            if (!resolved.api.apiKey) {
+                warnings.push('API_KEY_MISSING');
+                return { llm: new StubLLM(), backend: 'stub', warnings };
+            }
+            return {
+                llm: new AiSdkLLM({
+                    clientPackage,
+                    providerName: resolved.id,
+                    apiKey: resolved.api.apiKey,
+                    baseUrl: resolved.api.baseUrl,
+                    modelId: resolved.models.selectedModelId,
+                    headers: resolved.api.headers,
+                    timeoutMs: resolved.api.timeoutMs,
+                    langfuseEnabled: options?.langfuseEnabled,
+                }),
+                backend: 'ai-sdk',
+                warnings,
+            };
+        };
+    };
+    reg.register({ providerType: 'openai', clientPackage: '@ai-sdk/openai' }, buildAiSdk('@ai-sdk/openai'));
+    reg.register({ providerType: 'openai-compatible', clientPackage: '@ai-sdk/openai-compatible' }, buildAiSdk('@ai-sdk/openai-compatible'));
+    // Legacy/default client path (no client.package). This is intentionally not expressed as a registry entry.
+    // The factory decides when to fall back to a stable stub adapter based on provider family and apiKey.
+    return reg;
+}
+export function createDefaultOpenAiFallback(resolved, options) {
+    const warnings = [];
+    if (!resolved.api.apiKey) {
+        warnings.push('API_KEY_MISSING');
+        return { llm: new StubLLM(), backend: 'stub', warnings };
+    }
+    if (resolved.type !== 'openai' && resolved.type !== 'openai-compatible') {
+        warnings.push('PROVIDER_NOT_SUPPORTED');
+        return { llm: new StubLLM(), backend: 'stub', warnings };
+    }
+    // Prefer AI SDK for the default path.
+    const clientPackage = resolved.type === 'openai' ? '@ai-sdk/openai' : '@ai-sdk/openai-compatible';
+    return {
+        llm: new AiSdkLLM({
+            clientPackage,
+            providerName: resolved.id,
+            apiKey: resolved.api.apiKey,
+            baseUrl: resolved.api.baseUrl,
+            modelId: resolved.models.selectedModelId,
+            headers: resolved.api.headers,
+            timeoutMs: resolved.api.timeoutMs,
+            langfuseEnabled: options?.langfuseEnabled,
+        }),
+        backend: 'ai-sdk',
+        warnings,
+    };
+}
+//# sourceMappingURL=registry.js.map

package/dist/core/llm/retry-utils.js

@@ -0,0 +1,114 @@
+import { LIMITS } from '../config/limits.js';
+const DEFAULT_OPTIONS = {
+    maxRetries: LIMITS.retry.api.maxAttempts,
+    initialDelayMs: LIMITS.retry.api.initialDelayMs,
+    maxDelayMs: LIMITS.retry.api.maxDelayMs,
+    backoffFactor: 2,
+    jitterRatio: 0,
+    retryableErrors: () => true, // By default, retry all errors
+    onRetry: async () => { },
+};
+function withJitter(delayMs, jitterRatio) {
+    const ratio = Number.isFinite(jitterRatio) ? Math.max(0, Math.min(1, jitterRatio)) : 0;
+    if (ratio <= 0)
+        return delayMs;
+    const delta = (Math.random() * 2 - 1) * ratio;
+    return Math.max(0, Math.floor(delayMs * (1 + delta)));
+}
+/**
+ * Retries an async function with exponential backoff.
+ */
+export async function withRetry(fn, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    let lastError;
+    let delay = opts.initialDelayMs;
+    const signal = options.signal;
+    for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+        if (signal?.aborted) {
+            throw new Error('Operation aborted');
+        }
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === opts.maxRetries || !opts.retryableErrors(error)) {
+                throw error;
+            }
+            if (signal?.aborted) {
+                throw new Error('Operation aborted');
+            }
+            const effectiveDelay = withJitter(delay, opts.jitterRatio);
+            try {
+                await opts.onRetry({ attempt: attempt + 1, delayMs: effectiveDelay, error });
+            }
+            catch {
+                // Ignore onRetry handler failures.
+            }
+            await new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    resolve(undefined);
+                    signal?.removeEventListener('abort', onAbort);
+                }, effectiveDelay);
+                const onAbort = () => {
+                    clearTimeout(timer);
+                    reject(new Error('Operation aborted'));
+                    signal?.removeEventListener('abort', onAbort);
+                };
+                signal?.addEventListener('abort', onAbort);
+            });
+            delay = Math.min(delay * opts.backoffFactor, opts.maxDelayMs);
+        }
+    }
+    throw lastError;
+}
+/**
+ * Retries an async iterable (generator) with exponential backoff.
+ * Note: Retrying a stream usually means restarting the entire stream from the beginning.
+ */
+export async function* withStreamRetry(streamFactory, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    let lastError;
+    let delay = opts.initialDelayMs;
+    const signal = options.signal;
+    for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+        if (signal?.aborted) {
+            throw new Error('Operation aborted');
+        }
+        try {
+            yield* streamFactory();
+            return; // Success, exit generator
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === opts.maxRetries || !opts.retryableErrors(error)) {
+                throw error;
+            }
+            if (signal?.aborted) {
+                throw new Error('Operation aborted');
+            }
+            const effectiveDelay = withJitter(delay, opts.jitterRatio);
+            try {
+                await opts.onRetry({ attempt: attempt + 1, delayMs: effectiveDelay, error });
+            }
+            catch {
+                // Ignore onRetry handler failures.
+            }
+            await new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    resolve(undefined);
+                    signal?.removeEventListener('abort', onAbort);
+                }, effectiveDelay);
+                const onAbort = () => {
+                    clearTimeout(timer);
+                    reject(new Error('Operation aborted'));
+                    signal?.removeEventListener('abort', onAbort);
+                };
+                signal?.addEventListener('abort', onAbort);
+            });
+            delay = Math.min(delay * opts.backoffFactor, opts.maxDelayMs);
+        }
+    }
+    throw lastError;
+}
+//# sourceMappingURL=retry-utils.js.map

package/dist/core/llm/stream-utils.js

@@ -0,0 +1,87 @@
+function normalizeToolInput(raw) {
+    if (typeof raw !== 'string')
+        return raw;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return {};
+    try {
+        let parsed = JSON.parse(trimmed);
+        if (typeof parsed === 'string') {
+            const nested = parsed.trim();
+            if (nested.startsWith('{') || nested.startsWith('[')) {
+                try {
+                    parsed = JSON.parse(nested);
+                }
+                catch {
+                    // ignored
+                }
+            }
+        }
+        return parsed;
+    }
+    catch {
+        return raw;
+    }
+}
+export function mapAiSdkStreamPartToChunk(part) {
+    if (!part)
+        return null;
+    if (typeof part === 'string') {
+        return { role: 'assistant', source: 'provider', contentDelta: part };
+    }
+    if (typeof part !== 'object' || Array.isArray(part)) {
+        return null;
+    }
+    switch (part.type) {
+        case 'text-delta':
+        case 'reasoning-delta':
+            if (typeof part.text === 'string' && part.text) {
+                return { role: 'assistant', source: 'provider', contentDelta: part.text };
+            }
+            return null;
+        case 'tool-call':
+            return {
+                role: 'assistant',
+                source: 'provider',
+                tool_calls: [
+                    {
+                        id: part.toolCallId || 'unknown',
+                        type: 'function',
+                        function: {
+                            name: part.toolName || 'unknown',
+                            arguments: JSON.stringify(normalizeToolInput(part.input ?? {})),
+                        },
+                    },
+                ],
+            };
+        case 'finish':
+            return {
+                role: 'assistant',
+                source: 'provider',
+                done: true,
+                finishReason: part.finishReason,
+                usage: part.usage &&
+                    typeof part.usage === 'object' &&
+                    typeof part.usage.promptTokens === 'number' &&
+                    typeof part.usage.completionTokens === 'number'
+                    ? {
+                        promptTokens: part.usage.promptTokens,
+                        completionTokens: part.usage.completionTokens,
+                    }
+                    : undefined,
+            };
+        case 'error':
+            // We don't return a chunk for errors here; we want the generator to throw
+            return null;
+        case 'abort':
+            return {
+                role: 'assistant',
+                source: 'synthesized',
+                done: true,
+                finishReason: 'abort',
+            };
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=stream-utils.js.map

package/dist/core/llm/utils.js

@@ -0,0 +1,82 @@
+import { text } from '../../locales/index.js';
+import { LIMITS } from '../config/limits.js';
+import { ContextFormatConverter } from '../context/formatters/json-converter.js';
+import { formatContextForXmlPrompt } from '../context/formatters/xml-context.js';
+import { wrapPatchEmpty } from './errors.js';
+export function formatContextForPrompt(context, options = {}) {
+    const format = options.format ?? 'json';
+    if (format === 'json') {
+        return JSON.stringify(ContextFormatConverter.contextToJson(context));
+    }
+    return formatContextForXmlPrompt(context);
+}
+export function extractJson(content) {
+    // 1. Try to find JSON block
+    const jsonBlockMatch = content.match(/```json\s*\n([\s\S]*?)\n```/);
+    if (jsonBlockMatch) {
+        try {
+            return JSON.parse(jsonBlockMatch[1]);
+        }
+        catch (__e) {
+            // Fallback to raw content if block is invalid
+        }
+    }
+    // 2. Try to find anything that looks like a JSON object
+    const jsonMatch = content.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+        try {
+            return JSON.parse(jsonMatch[0]);
+        }
+        catch (__e) {
+            // Fallback
+        }
+    }
+    // 3. Final fallback: try parsing the whole content
+    return JSON.parse(content);
+}
+export function parsePlanFromLLMContent(content) {
+    const plan = extractJson(content);
+    if (!plan.goal || !Array.isArray(plan.files) || !Array.isArray(plan.changes) || !plan.verify) {
+        throw new Error(text.llm.planInvalid);
+    }
+    return plan;
+}
+export function extractUnifiedDiffFromLLMContent(content) {
+    if (!content) {
+        throw wrapPatchEmpty();
+    }
+    const looksLikeUnifiedDiff = (text) => {
+        return /^\s*(diff --git |--- a\/)/m.test(text);
+    };
+    // 1) Prefer fenced code blocks and always pick the LAST diff-like block (LLM may generate multiple attempts).
+    // Accept both git-style (`diff --git`) and minimal unified diffs (`--- a/...` + `+++ b/...`).
+    const fencedBlocks = [];
+    const fenceRegex = /```(?:diff)?\s*\n([\s\S]*?)\n```/gi;
+    let fenceMatch = null;
+    while ((fenceMatch = fenceRegex.exec(content)) !== null) {
+        const block = fenceMatch[1];
+        if (typeof block === 'string' && looksLikeUnifiedDiff(block)) {
+            fencedBlocks.push(block);
+        }
+    }
+    if (fencedBlocks.length > 0) {
+        return fencedBlocks[fencedBlocks.length - 1].trim();
+    }
+    // 2) Raw diff without markdown: keep the first diff-like section.
+    // In "pure diff" mode, LLMs typically return only the patch, so selecting the first marker
+    // avoids accidentally dropping the leading `diff --git` header.
+    const rawStart = content.search(/^\s*(diff --git |--- a\/)/m);
+    if (rawStart !== -1)
+        return content.slice(rawStart).trim();
+    // Final fallback: original simple cleanup
+    let cleanContent = content;
+    cleanContent = cleanContent.replace(/^```(?:diff)?\s*\n/, '');
+    cleanContent = cleanContent.replace(/\n```\s*$/, '');
+    const trimmed = cleanContent.trim();
+    if (trimmed.length > LIMITS.maxDiffLines * 200) {
+        // This is a heuristic guardrail to prevent accidentally treating a large non-diff blob as a patch.
+        // The caller can still decide how to handle this.
+    }
+    return trimmed;
+}
+//# sourceMappingURL=utils.js.map

package/dist/core/observability/audit-file.js

@@ -0,0 +1,199 @@
+import path from 'path';
+import { text } from '../../locales/index.js';
+import { appendFile, mkdir, readFile, rename, writeFile } from '../adapters/fs/node-fs.js';
+import { getAuditDir } from '../runtime/paths.js';
+import { getAuditTrail } from './audit-trail.js';
+import { mapAuditTrailToSecondaryFailures, mapErrorForAudit, } from './error-mapping.js';
+import { getLogger } from './logger.js';
+function toSecondaryFailureMeta(failures) {
+    return failures.map((failure) => ({
+        source: failure.source,
+        category: failure.category,
+        summary: failure.summary,
+        redacted: failure.redacted,
+    }));
+}
+function toParams(input) {
+    if (typeof input === 'string' || input === undefined) {
+        return { auditPath: input };
+    }
+    return input;
+}
+async function writeJsonAtomic(targetPath, data) {
+    const dir = path.dirname(targetPath);
+    const base = path.basename(targetPath);
+    const tmpPath = path.join(dir, `.${base}.tmp-${process.pid}-${Date.now()}`);
+    const payload = JSON.stringify(data, null, 2);
+    await writeFile(tmpPath, payload);
+    try {
+        await rename(tmpPath, targetPath);
+    }
+    catch {
+        // Retry once with a fresh temp file to reduce transient rename failures.
+        const retryTmpPath = path.join(dir, `.${base}.tmp-${process.pid}-${Date.now()}-retry`);
+        await writeFile(retryTmpPath, payload);
+        await rename(retryTmpPath, targetPath);
+    }
+}
+function resolveEventsPath(eventsPath, auditPath) {
+    if (path.isAbsolute(eventsPath))
+        return eventsPath;
+    return path.join(path.dirname(auditPath), eventsPath);
+}
+function buildEventsPayload(events) {
+    if (events.length === 0)
+        return '';
+    return `${events.map((event) => JSON.stringify(event)).join('\n')}\n`;
+}
+async function createFallbackAuditFile(params) {
+    if (!params.repoPath)
+        return undefined;
+    const trail = getAuditTrail();
+    if (trail.length === 0)
+        return undefined;
+    const auditDir = getAuditDir(params.repoPath, params.auditScope);
+    await mkdir(auditDir, { recursive: true });
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const filename = `audit-fallback-${timestamp}.json`;
+    const targetPath = path.join(auditDir, filename);
+    const eventsFilename = filename.replace(/\.json$/, '.events.jsonl');
+    const eventsPath = path.join(auditDir, eventsFilename);
+    const auditError = mapErrorForAudit({
+        message: params.failureReason,
+        code: params.finalOutcome?.errorCode ?? params.finalOutcome?.reasonCode,
+    });
+    const secondaryFailures = mapAuditTrailToSecondaryFailures(trail);
+    const payload = {
+        meta: {
+            timestamp: new Date().toISOString(),
+            success: params.finalOutcome?.success ?? false,
+            reasonCode: params.finalOutcome?.reasonCode,
+            failurePhase: params.finalOutcome?.failurePhase,
+            errorCode: params.finalOutcome?.errorCode,
+            errorCategory: auditError.category,
+            errorSummary: auditError.summary,
+            primaryFailure: {
+                code: auditError.code,
+                category: auditError.category,
+                summary: auditError.summary,
+                redacted: auditError.redacted,
+            },
+            secondaryFailures: toSecondaryFailureMeta(secondaryFailures),
+            error: params.failureReason,
+            runId: params.runId,
+            source: 'appendAuditTrailToAuditFile.fallback',
+        },
+        traces: [],
+        context: {
+            eventsRef: {
+                path: eventsFilename,
+                count: trail.length,
+                firstTs: trail[0]?.timestamp,
+                lastTs: trail[trail.length - 1]?.timestamp,
+            },
+        },
+    };
+    await writeFile(eventsPath, buildEventsPayload(trail), 'utf8');
+    await writeJsonAtomic(targetPath, payload);
+    return targetPath;
+}
+export async function appendAuditTrailToAuditFile(input) {
+    const params = toParams(input);
+    const auditPath = params.auditPath;
+    try {
+        if (!auditPath) {
+            return await createFallbackAuditFile(params);
+        }
+        const raw = await readFile(auditPath, 'utf8');
+        const data = JSON.parse(raw);
+        const meta = data.meta && typeof data.meta === 'object' ? data.meta : {};
+        const fullTrail = getAuditTrail();
+        let metaChanged = false;
+        if (params.finalOutcome) {
+            const auditError = mapErrorForAudit({
+                message: params.failureReason ?? (typeof meta.error === 'string' ? meta.error : undefined),
+                code: params.finalOutcome.errorCode ?? params.finalOutcome.reasonCode,
+            });
+            const secondaryFailures = mapAuditTrailToSecondaryFailures(fullTrail);
+            if (meta.success !== params.finalOutcome.success) {
+                meta.success = params.finalOutcome.success;
+                metaChanged = true;
+            }
+            if (params.finalOutcome.reasonCode !== undefined &&
+                meta.reasonCode !== params.finalOutcome.reasonCode) {
+                meta.reasonCode = params.finalOutcome.reasonCode;
+                metaChanged = true;
+            }
+            if (params.finalOutcome.failurePhase !== undefined &&
+                meta.failurePhase !== params.finalOutcome.failurePhase) {
+                meta.failurePhase = params.finalOutcome.failurePhase;
+                metaChanged = true;
+            }
+            if (params.finalOutcome.errorCode !== undefined &&
+                meta.errorCode !== params.finalOutcome.errorCode) {
+                meta.errorCode = params.finalOutcome.errorCode;
+                metaChanged = true;
+            }
+            if (meta.errorCategory !== auditError.category) {
+                meta.errorCategory = auditError.category;
+                metaChanged = true;
+            }
+            if (meta.errorSummary !== auditError.summary) {
+                meta.errorSummary = auditError.summary;
+                metaChanged = true;
+            }
+            const nextPrimaryFailure = {
+                code: auditError.code,
+                category: auditError.category,
+                summary: auditError.summary,
+                redacted: auditError.redacted,
+            };
+            const primaryDigest = JSON.stringify(meta.primaryFailure ?? null);
+            const nextPrimaryDigest = JSON.stringify(nextPrimaryFailure);
+            if (primaryDigest !== nextPrimaryDigest) {
+                meta.primaryFailure = nextPrimaryFailure;
+                metaChanged = true;
+            }
+            const nextSecondaryFailures = toSecondaryFailureMeta(secondaryFailures);
+            const secondaryDigest = JSON.stringify(meta.secondaryFailures ?? []);
+            const nextSecondaryDigest = JSON.stringify(nextSecondaryFailures);
+            if (secondaryDigest !== nextSecondaryDigest) {
+                meta.secondaryFailures = nextSecondaryFailures;
+                metaChanged = true;
+            }
+            data.meta = meta;
+        }
+        const context = data.context && typeof data.context === 'object'
+            ? data.context
+            : {};
+        const eventsRef = context.eventsRef;
+        if (!eventsRef?.path) {
+            throw new Error('Invalid audit file: context.eventsRef.path is required');
+        }
+        const existingCount = typeof eventsRef.count === 'number' && Number.isFinite(eventsRef.count) ? eventsRef.count : 0;
+        const delta = fullTrail.slice(existingCount);
+        if (delta.length === 0) {
+            if (!metaChanged)
+                return;
+            await writeJsonAtomic(auditPath, data);
+            return auditPath;
+        }
+        const eventsPath = resolveEventsPath(eventsRef.path, auditPath);
+        await appendFile(eventsPath, buildEventsPayload(delta), 'utf8');
+        context.eventsRef = {
+            ...eventsRef,
+            count: existingCount + delta.length,
+            firstTs: eventsRef.firstTs ?? delta[0]?.timestamp,
+            lastTs: delta[delta.length - 1]?.timestamp ?? eventsRef.lastTs,
+        };
+        data.context = context;
+        await writeJsonAtomic(auditPath, data);
+        return auditPath;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        getLogger().warn(text.grizzco.audit.appendFailed(msg));
+        return undefined;
+    }
+}
+//# sourceMappingURL=audit-file.js.map