salmon-loop 0.2.3 → 0.2.16

package/dist/core/session/replacement-state.js

@@ -0,0 +1,131 @@
+import { createHash } from 'crypto';
+export const TOOL_RESULT_REPLACEMENT_IDENTITY_VERSION = 'v1';
+export const TOOL_RESULT_REPLACEMENT_HASH_ALGORITHM = 'sha256';
+export const TOOL_RESULT_REPLACEMENT_STATE_SCHEMA_VERSION = 1;
+const DEFAULT_MAX_ENTRIES = 256;
+function normalizeNewlines(value) {
+    return value.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+function canonicalize(value) {
+    if (value === null)
+        return 'null';
+    if (typeof value === 'string') {
+        return JSON.stringify(normalizeNewlines(value));
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            return JSON.stringify(String(value));
+        return JSON.stringify(Number(value));
+    }
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => canonicalize(item)).join(',')}]`;
+    }
+    if (typeof value === 'object') {
+        const record = value;
+        const keys = Object.keys(record).sort();
+        const pairs = keys.map((key) => `${JSON.stringify(key)}:${canonicalize(record[key])}`);
+        return `{${pairs.join(',')}}`;
+    }
+    return JSON.stringify(String(value));
+}
+export function createToolResultIdentity(params) {
+    const payloadBytes = canonicalize(params.payload);
+    const hash = createHash(TOOL_RESULT_REPLACEMENT_HASH_ALGORITHM);
+    hash.update(TOOL_RESULT_REPLACEMENT_IDENTITY_VERSION);
+    hash.update('\n');
+    hash.update(normalizeNewlines(params.canonicalToolCallIdentity).trim());
+    hash.update('\n');
+    hash.update(payloadBytes);
+    return hash.digest('hex');
+}
+function isValidEntry(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const entry = value;
+    if (!entry.toolResultId || typeof entry.toolResultId !== 'string')
+        return false;
+    if (entry.decision !== 'kept' && entry.decision !== 'replaced')
+        return false;
+    if (typeof entry.preview !== 'string')
+        return false;
+    if (typeof entry.frozenAt !== 'number' || !Number.isFinite(entry.frozenAt))
+        return false;
+    if (entry.sourceArtifactHandle !== undefined && typeof entry.sourceArtifactHandle !== 'string') {
+        return false;
+    }
+    if (entry.identityVersion !== TOOL_RESULT_REPLACEMENT_IDENTITY_VERSION)
+        return false;
+    if (entry.hashAlgorithm !== TOOL_RESULT_REPLACEMENT_HASH_ALGORITHM)
+        return false;
+    return true;
+}
+export function normalizeToolResultReplacementState(state) {
+    if (!state || typeof state !== 'object')
+        return undefined;
+    if (state.schemaVersion !== TOOL_RESULT_REPLACEMENT_STATE_SCHEMA_VERSION)
+        return undefined;
+    if (!state.entries || typeof state.entries !== 'object')
+        return undefined;
+    const normalizedEntries = {};
+    for (const [key, value] of Object.entries(state.entries)) {
+        if (!isValidEntry(value))
+            continue;
+        if (value.toolResultId !== key)
+            continue;
+        normalizedEntries[key] = {
+            toolResultId: value.toolResultId,
+            decision: value.decision,
+            preview: value.preview,
+            frozenAt: value.frozenAt,
+            sourceArtifactHandle: value.sourceArtifactHandle,
+            identityVersion: value.identityVersion,
+            hashAlgorithm: value.hashAlgorithm,
+        };
+    }
+    if (Object.keys(normalizedEntries).length === 0)
+        return undefined;
+    return {
+        schemaVersion: TOOL_RESULT_REPLACEMENT_STATE_SCHEMA_VERSION,
+        entries: normalizedEntries,
+    };
+}
+export function createEmptyToolResultReplacementState() {
+    return {
+        schemaVersion: TOOL_RESULT_REPLACEMENT_STATE_SCHEMA_VERSION,
+        entries: {},
+    };
+}
+export function freezeToolResultReplacementDecision(state, entry, options) {
+    const base = normalizeToolResultReplacementState(state) ?? createEmptyToolResultReplacementState();
+    const existing = base.entries[entry.toolResultId];
+    if (existing) {
+        return base;
+    }
+    const nextEntries = {
+        ...base.entries,
+        [entry.toolResultId]: {
+            toolResultId: entry.toolResultId,
+            decision: entry.decision,
+            preview: entry.preview,
+            frozenAt: entry.frozenAt ?? Date.now(),
+            sourceArtifactHandle: entry.sourceArtifactHandle,
+            identityVersion: TOOL_RESULT_REPLACEMENT_IDENTITY_VERSION,
+            hashAlgorithm: TOOL_RESULT_REPLACEMENT_HASH_ALGORITHM,
+        },
+    };
+    const maxEntries = Math.max(1, options?.maxEntries ?? DEFAULT_MAX_ENTRIES);
+    const keys = Object.keys(nextEntries);
+    if (keys.length > maxEntries) {
+        const sorted = keys.sort((a, b) => nextEntries[a].frozenAt - nextEntries[b].frozenAt);
+        for (const evict of sorted.slice(0, keys.length - maxEntries)) {
+            delete nextEntries[evict];
+        }
+    }
+    return {
+        schemaVersion: TOOL_RESULT_REPLACEMENT_STATE_SCHEMA_VERSION,
+        entries: nextEntries,
+    };
+}
+//# sourceMappingURL=replacement-state.js.map

package/dist/core/session/resume-repair/pipeline.js

@@ -0,0 +1,79 @@
+import { randomBytes } from 'crypto';
+import { loadRawArchiveStateStage } from './stages/load-raw-archive-state.js';
+import { reattachRuntimeStateStage } from './stages/reattach-runtime-state.js';
+import { recoverOrphanedBranchesStage } from './stages/recover-orphaned-branches.js';
+import { relinkBoundaryAndTailStage } from './stages/relink-boundary-and-tail.js';
+import { replayStartupHooksStage } from './stages/replay-startup-hooks.js';
+import { rescueStaleMetadataStage } from './stages/rescue-stale-metadata.js';
+export function createResumeRepairPipeline(params) {
+    const context = {
+        repoPath: params.repoPath,
+        now: params.now ?? (() => Date.now()),
+        nextId: params.nextId ?? (() => randomBytes(6).toString('hex')),
+        startupHooks: params.startupHooks ?? [],
+    };
+    return {
+        async run(input) {
+            const compressed = await params.compressedStore.loadCompressed(input.filename);
+            if (!compressed) {
+                return {
+                    warnings: [],
+                    repairActions: [],
+                    contractViolations: [
+                        {
+                            code: 'ARCHIVE_CORRUPTED',
+                            message: `Archive "${input.archiveId}" cannot be loaded.`,
+                        },
+                    ],
+                };
+            }
+            const partial = await params.compressor.decompressToSession(compressed);
+            const state = {
+                archiveId: input.archiveId,
+                filename: input.filename,
+                compressed,
+                partial,
+                session: {
+                    meta: {
+                        id: '',
+                        name: '',
+                        repoPath: context.repoPath,
+                        createdAt: 0,
+                        updatedAt: 0,
+                        totalIterations: 0,
+                        successfulIterations: 0,
+                        totalTokens: { input: 0, output: 0 },
+                        snapshots: [],
+                    },
+                    messages: [],
+                    iterations: [],
+                },
+                warnings: [],
+                repairActions: [],
+                contractViolations: [],
+            };
+            const stages = [
+                loadRawArchiveStateStage,
+                rescueStaleMetadataStage,
+                relinkBoundaryAndTailStage,
+                recoverOrphanedBranchesStage,
+                reattachRuntimeStateStage,
+                replayStartupHooksStage,
+            ];
+            for (const stage of stages) {
+                await stage(state, context);
+                if (state.contractViolations.length > 0) {
+                    break;
+                }
+            }
+            return {
+                session: state.contractViolations.length > 0 ? undefined : state.session,
+                replacementState: state.replacementState,
+                warnings: state.warnings,
+                repairActions: state.repairActions,
+                contractViolations: state.contractViolations,
+            };
+        },
+    };
+}
+//# sourceMappingURL=pipeline.js.map

package/dist/core/session/resume-repair/stages/load-raw-archive-state.js

@@ -0,0 +1,40 @@
+import { parseFlowMode } from '../../../types/flow-mode.js';
+import { normalizeSessionArtifactState } from '../../artifact-state.js';
+import { normalizeToolResultReplacementState } from '../../replacement-state.js';
+export const loadRawArchiveStateStage = async (state, context) => {
+    const partial = state.partial;
+    const flowMode = parseFlowMode(partial.meta.chatState?.flowMode);
+    const reconstructed = {
+        meta: {
+            id: partial.meta.id,
+            name: partial.meta.name,
+            repoPath: context.repoPath,
+            createdAt: partial.meta.createdAt,
+            updatedAt: context.now(),
+            totalIterations: partial.meta.totalIterations ?? partial.iterations.length,
+            successfulIterations: partial.meta.successfulIterations ?? 0,
+            totalTokens: partial.meta.totalTokens ?? { input: 0, output: 0 },
+            snapshots: [],
+            chatState: flowMode ? { flowMode } : undefined,
+            artifactState: normalizeSessionArtifactState(partial.meta.artifactState),
+            replacementState: normalizeToolResultReplacementState(partial.meta.replacementState),
+        },
+        messages: partial.messages.map((message, index) => ({
+            id: `restored-msg-${index}`,
+            role: message.role,
+            content: message.content,
+            timestamp: message.timestamp,
+        })),
+        iterations: partial.iterations.map((iteration, index) => ({
+            id: iteration.id || `restored-iter-${index + 1}`,
+            attempt: index + 1,
+            plan: null,
+            patch: null,
+            error: iteration.outcome === 'failure' ? iteration.summary : undefined,
+            contextSummary: iteration.summary,
+        })),
+    };
+    state.session = reconstructed;
+    state.replacementState = reconstructed.meta.replacementState;
+};
+//# sourceMappingURL=load-raw-archive-state.js.map

package/dist/core/session/resume-repair/stages/reattach-runtime-state.js

@@ -0,0 +1,8 @@
+import { normalizeSessionArtifactState } from '../../artifact-state.js';
+import { normalizeToolResultReplacementState } from '../../replacement-state.js';
+export const reattachRuntimeStateStage = async (state) => {
+    state.session.meta.artifactState = normalizeSessionArtifactState(state.session.meta.artifactState);
+    state.replacementState = normalizeToolResultReplacementState(state.replacementState);
+    state.session.meta.replacementState = state.replacementState;
+};
+//# sourceMappingURL=reattach-runtime-state.js.map

package/dist/core/session/resume-repair/stages/recover-orphaned-branches.js

@@ -0,0 +1,10 @@
+export const recoverOrphanedBranchesStage = async (state) => {
+    if (state.session.iterations.length > state.session.meta.totalIterations) {
+        state.session.meta.totalIterations = state.session.iterations.length;
+        state.repairActions.push({
+            code: 'RECOVERED_ITERATION_COUNT',
+            detail: 'Normalized stale totalIterations from recovered iteration list.',
+        });
+    }
+};
+//# sourceMappingURL=recover-orphaned-branches.js.map

package/dist/core/session/resume-repair/stages/relink-boundary-and-tail.js

@@ -0,0 +1,36 @@
+function hasFiniteTimestamp(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0;
+}
+export const relinkBoundaryAndTailStage = async (state) => {
+    const meta = state.session.meta;
+    if (!meta.id ||
+        !meta.name ||
+        !hasFiniteTimestamp(meta.createdAt) ||
+        !hasFiniteTimestamp(meta.updatedAt)) {
+        state.contractViolations.push({
+            code: 'MALFORMED_SESSION_BOUNDARY_METADATA',
+            message: 'Archive metadata failed boundary validation.',
+        });
+        return;
+    }
+    const invalidMessage = state.session.messages.some((message) => !hasFiniteTimestamp(message.timestamp) || !message.id);
+    if (invalidMessage) {
+        state.contractViolations.push({
+            code: 'MALFORMED_MESSAGE_BOUNDARY_METADATA',
+            message: 'Recovered messages contain invalid boundary metadata.',
+        });
+        return;
+    }
+    const invalidIteration = state.session.iterations.some((iteration) => typeof iteration.id !== 'string' ||
+        !iteration.id ||
+        !Number.isInteger(iteration.attempt) ||
+        iteration.attempt <= 0 ||
+        typeof iteration.contextSummary !== 'string');
+    if (invalidIteration) {
+        state.contractViolations.push({
+            code: 'MALFORMED_TAIL_ITERATION_METADATA',
+            message: 'Recovered iterations contain invalid tail metadata.',
+        });
+    }
+};
+//# sourceMappingURL=relink-boundary-and-tail.js.map

package/dist/core/session/resume-repair/stages/replay-startup-hooks.js

@@ -0,0 +1,23 @@
+export const replayStartupHooksStage = async (state, context) => {
+    const executed = new Set();
+    for (const hook of context.startupHooks) {
+        if (!hook?.key || executed.has(hook.key))
+            continue;
+        executed.add(hook.key);
+        try {
+            await hook.run(state.session, {
+                now: context.now,
+                nextId: context.nextId,
+            });
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            state.contractViolations.push({
+                code: 'STARTUP_HOOK_FAILED',
+                message: `Startup hook "${hook.key}" failed: ${reason}`,
+            });
+            return;
+        }
+    }
+};
+//# sourceMappingURL=replay-startup-hooks.js.map

package/dist/core/session/resume-repair/stages/rescue-stale-metadata.js

@@ -0,0 +1,17 @@
+export const rescueStaleMetadataStage = async (state, context) => {
+    if (!state.session.meta.name.trim()) {
+        state.session.meta.name = `Recovered ${state.session.meta.id}`;
+        state.repairActions.push({
+            code: 'RESCUED_EMPTY_NAME',
+            detail: 'Recovered missing session name from archive metadata.',
+        });
+    }
+    if (state.session.meta.updatedAt < state.session.meta.createdAt) {
+        state.session.meta.updatedAt = context.now();
+        state.repairActions.push({
+            code: 'RESCUED_UPDATED_AT',
+            detail: 'Adjusted stale updatedAt to a valid timestamp.',
+        });
+    }
+};
+//# sourceMappingURL=rescue-stale-metadata.js.map

package/dist/core/session/resume-repair/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/session/summary-sync.js

@@ -1,11 +1,100 @@
 import { ConversationSummarizer } from '../context/summarization/summarizer.js';
 import { DEFAULT_SUMMARIZATION_CONFIG } from '../context/summarization/types.js';
+import { microcompact } from './compaction/microcompact.js';
+import { buildSessionConversationContext } from './session-context-builder.js';
 import { TokenTracker } from './token-tracker.js';
+const MAX_RECOVERY_READ_FILES = 6;
+const MAX_RECOVERY_SAFE_HINT_CHARS = 240;
+function trimToUndefined(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function clampText(value, maxChars) {
+    if (!value)
+        return undefined;
+    if (value.length <= maxChars)
+        return value;
+    return `${value.slice(0, Math.max(0, maxChars - 1)).trimEnd()}…`;
+}
+function normalizeFailureSummary(value) {
+    if (!value)
+        return undefined;
+    const next = {};
+    const reasonCode = trimToUndefined(value.reasonCode);
+    if (reasonCode)
+        next.reasonCode = reasonCode;
+    const diagnosticCode = trimToUndefined(value.diagnosticCode);
+    if (diagnosticCode)
+        next.diagnosticCode = diagnosticCode;
+    const safeHint = clampText(trimToUndefined(value.safeHint), MAX_RECOVERY_SAFE_HINT_CHARS);
+    if (safeHint)
+        next.safeHint = safeHint;
+    const failurePhase = trimToUndefined(value.failurePhase);
+    if (failurePhase)
+        next.failurePhase = failurePhase;
+    return Object.keys(next).length > 0 ? next : undefined;
+}
+function normalizeRecentReadFiles(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    const unique = [];
+    const seen = new Set();
+    for (const entry of value) {
+        const path = trimToUndefined(typeof entry === 'string' ? entry : entry?.path);
+        if (!path || seen.has(path))
+            continue;
+        seen.add(path);
+        unique.push(path);
+    }
+    if (unique.length === 0)
+        return undefined;
+    return unique.slice(-MAX_RECOVERY_READ_FILES);
+}
+function buildRecoveryState(params) {
+    const { sessionManager, persistedState, patch } = params;
+    const next = {};
+    const flowMode = sessionManager.getChatFlowMode?.() ?? persistedState?.recoveryState?.flowMode;
+    if (flowMode) {
+        next.flowMode = flowMode;
+    }
+    const recentReadFiles = normalizeRecentReadFiles(sessionManager.getArtifactState?.()?.recentReadArtifacts ??
+        persistedState?.recoveryState?.recentReadFiles);
+    if (recentReadFiles?.length) {
+        next.recentReadFiles = recentReadFiles;
+    }
+    const lastFailureSummary = patch && 'lastFailureSummary' in patch
+        ? normalizeFailureSummary(patch.lastFailureSummary)
+        : normalizeFailureSummary(persistedState?.recoveryState?.lastFailureSummary);
+    if (lastFailureSummary) {
+        next.lastFailureSummary = lastFailureSummary;
+    }
+    return Object.keys(next).length > 0 ? next : undefined;
+}
+function buildRecoveryStateMessage(summaryState) {
+    const recoveryState = summaryState?.recoveryState;
+    if (!recoveryState)
+        return undefined;
+    return {
+        role: 'system',
+        content: `[Conversation recovery state]\n${JSON.stringify(recoveryState)}`,
+    };
+}
+function fitRecoveryStateMessage(params) {
+    const { message, budgetTokens, countTokens } = params;
+    if (!message)
+        return undefined;
+    if (budgetTokens <= 0)
+        return undefined;
+    const tokens = Math.max(0, Math.floor(countTokens(message.content)));
+    return tokens <= budgetTokens ? message : undefined;
+}
 export async function refreshSessionSummary(params) {
     const { sessionManager, llm, contextHash } = params;
     const strategy = params.strategy ?? 'auto';
     if (!sessionManager)
-        return;
+        return { didSummarize: false };
     try {
         const summarizer = new ConversationSummarizer({
             chat: async ({ messages, temperature, maxTokens }) => {
@@ -32,33 +121,58 @@ export async function refreshSessionSummary(params) {
         if (persistedState) {
             summarizer.restoreState(persistedState);
         }
-        const messages = sessionManager.getMessagesWithIds().map((msg) => ({
-            id: msg.id,
+        const rawMessages = sessionManager.getMessagesWithIds();
+        const messages = microcompact(rawMessages).map((msg, index) => ({
+            id: msg.id ?? rawMessages[index]?.id ?? `msg-${index}-${msg.timestamp}`,
             role: msg.role,
             content: msg.content,
             timestamp: msg.timestamp,
         }));
+        let didSummarize = false;
         if (strategy === 'force') {
-            await summarizer.forceSummarize(messages, contextHash);
+            const result = await summarizer.forceSummarize(messages, contextHash);
+            didSummarize = Boolean(result);
         }
         else {
-            await summarizer.triggerSummarization(messages, contextHash);
+            const result = await summarizer.triggerSummarization(messages, contextHash);
+            didSummarize = Boolean(result);
         }
-        sessionManager.updateSummaryState(summarizer.getState());
+        const nextState = summarizer.getState();
+        nextState.recoveryState = buildRecoveryState({
+            sessionManager,
+            persistedState,
+            patch: params.recoveryStatePatch,
+        });
+        sessionManager.updateSummaryState(nextState);
+        return { didSummarize };
     }
-    catch {
-        // Best-effort summary update: never affect execution flow.
+    catch (error) {
+        if (params.strict) {
+            throw error;
+        }
+        return { didSummarize: false, error: error instanceof Error ? error.message : String(error) };
     }
 }
 export function buildEffectiveConversationContext(params) {
     const { sessionManager } = params;
     const summaryState = sessionManager.getSummaryState();
-    const messages = sessionManager.getMessagesWithIds().map((msg) => ({
-        id: msg.id,
+    const countTokens = params.countTokens ?? ((text) => TokenTracker.estimateTokens(text));
+    // Apply microcompact (Level 0) to all messages before building context
+    // This is a "view-only" operation that doesn't modify sessionManager history
+    const rawMessages = params.messages ?? sessionManager.getMessages();
+    const messages = microcompact(rawMessages).map((msg, index) => ({
+        id: msg.id ?? `msg-${index}-${msg.timestamp}`,
         role: msg.role,
         content: msg.content,
         timestamp: msg.timestamp,
     }));
+    if (!summaryState) {
+        return buildSessionConversationContext(messages, {
+            budgetTokens: params.budgetTokens ?? Number.MAX_SAFE_INTEGER,
+            maxMessages: params.maxMessages,
+            countTokens,
+        });
+    }
     const summarizer = new ConversationSummarizer({
         chat: async () => ({ content: '' }),
     }, {
@@ -75,8 +189,45 @@ export function buildEffectiveConversationContext(params) {
     if (summaryState) {
         summarizer.restoreState(summaryState);
     }
-    return summarizer
-        .getEffectiveContext(messages)
-        .map((m) => ({ role: m.role, content: m.content }));
+    const effective = summarizer.getEffectiveContext(messages);
+    const recentMessages = effective
+        .filter((message) => message.role === 'user' || message.role === 'assistant')
+        .map((message) => ({
+        id: message.id,
+        role: message.role,
+        content: message.content,
+        timestamp: message.timestamp,
+    }));
+    const recoveryMessage = fitRecoveryStateMessage({
+        message: buildRecoveryStateMessage(summaryState),
+        budgetTokens: params.budgetTokens ?? Number.MAX_SAFE_INTEGER,
+        countTokens,
+    });
+    const recoveryBudget = recoveryMessage && params.budgetTokens !== undefined
+        ? Math.max(0, params.budgetTokens - Math.max(0, Math.floor(countTokens(recoveryMessage.content))))
+        : params.budgetTokens;
+    const summaryStateForContext = summaryState.recoveryState === undefined
+        ? summaryState
+        : {
+            ...summaryState,
+            recoveryState: undefined,
+        };
+    const built = buildSessionConversationContext(recentMessages, {
+        budgetTokens: recoveryBudget ?? Number.MAX_SAFE_INTEGER,
+        maxMessages: params.maxMessages,
+        countTokens,
+        summaryState: summaryStateForContext,
+    });
+    if (!recoveryMessage)
+        return built;
+    let systemPrefixLength = 0;
+    while (systemPrefixLength < built.length && built[systemPrefixLength]?.role === 'system') {
+        systemPrefixLength += 1;
+    }
+    return [
+        ...built.slice(0, systemPrefixLength),
+        recoveryMessage,
+        ...built.slice(systemPrefixLength),
+    ];
 }
 //# sourceMappingURL=summary-sync.js.map

package/dist/core/session/token-tracker.js

@@ -78,5 +78,11 @@ export class TokenTracker {
     static estimateTokens(text) {
         return Math.ceil(text.length / 4);
     }
+    /**
+     * Estimate total tokens for a list of messages
+     */
+    static estimateMessagesTokens(messages) {
+        return messages.reduce((sum, m) => sum + this.estimateTokens(m.content), 0);
+    }
 }
 //# sourceMappingURL=token-tracker.js.map

package/dist/core/skills/audit.js

@@ -0,0 +1,34 @@
+import * as crypto from 'crypto';
+import { tryGetLogger } from '../observability/logger.js';
+/**
+ * Compute a stable SHA-256 hash (truncated to 16 hex chars) of the given arguments text.
+ */
+export function hashSkillArgs(argsText) {
+    if (!argsText)
+        return undefined;
+    return crypto.createHash('sha256').update(argsText).digest('hex').slice(0, 16);
+}
+/**
+ * Generate a unique trace ID for a skill execution.
+ */
+export function generateSkillTraceId(skillId) {
+    return `skill-${skillId}-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
+}
+/**
+ * Emit a structured skill audit event via the logger audit trail.
+ *
+ * Uses `logger.audit()` to ensure events are persisted in the audit trail
+ * with appropriate severity and source metadata.
+ */
+export function emitSkillAuditEvent(event) {
+    const logger = tryGetLogger();
+    if (!logger)
+        return;
+    const severity = event.type === 'SKILL_EXECUTION_DENIED' ? 'high' : 'low';
+    logger.audit(event.type, event, {
+        source: 'skill-executor',
+        severity,
+        scope: 'session',
+    });
+}
+//# sourceMappingURL=audit.js.map