salmon-loop 0.2.13 → 0.2.16

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

package/dist/core/skills/bridge.js

@@ -1,14 +1,57 @@
 import { z } from 'zod';
-import { MicroTaskRunner } from './runtime/MicroTaskRunner.js';
+import { tryGetLogger } from '../observability/logger.js';
+import { emitSkillAuditEvent, generateSkillTraceId, hashSkillArgs } from './audit.js';
+import { getSkillFeatureFlags } from './feature-flags.js';
+import { executeSkill } from './runtime/SkillRunner.js';
 /**
- * Bridges a Skill into a ToolSpec compatible with the standard tool registry.
+ * Check whether the bridge execution path kill-switch is active.
+ *
+ * Delegates to the centralized {@link getSkillFeatureFlags} module which
+ * reads `SALMONLOOP_DISABLE_BRIDGE_SKILL_EXEC` from the environment.
+ *
+ *   - 'true' or '1'  → bridge disabled (kill-switch ON)
+ *   - 'false' or '0' → bridge enabled  (kill-switch OFF)
+ *   - not set         → disabled in non-dev, enabled in development
+ *
+ * @see Requirements 9.4, 11.4
  */
-export function skillToToolSpec(skill) {
+export function isBridgeSkillExecDisabled() {
+    return getSkillFeatureFlags().bridgeDisabled;
+}
+function isLazySource(source) {
+    return 'entry' in source && 'loader' in source;
+}
+/**
+ * Bridges a Skill (or catalog entry) into a ToolSpec compatible with the
+ * standard tool registry.
+ *
+ * When given a catalog entry + loader, the executor performs Tier 2 activation
+ * on first invocation (progressive disclosure). When given a full Skill, it
+ * executes immediately.
+ *
+ * The executor delegates to executeSkill() which routes all shell commands
+ * through ToolRouter governance (Registry → Validation → Policy → Auth).
+ *
+ * When the kill-switch env var `SALMONLOOP_DISABLE_BRIDGE_SKILL_EXEC` is
+ * set to 'true' or '1', the executor returns a DENIED result and emits
+ * a SKILL_EXECUTION_DENIED audit event instead of executing the skill.
+ *
+ * @param source - Either a full {@link Skill} or a `{ entry, loader }` pair
+ *   for lazy activation.
+ * @param routerBox - A mutable box whose `.router` field will be populated
+ *   after the ToolRouter is created. The executor reads it lazily at call
+ *   time, so it is safe to pass an initially-null box.
+ */
+export function skillToToolSpec(source, routerBox) {
+    const skillId = isLazySource(source) ? source.entry.id : source.id;
+    const description = isLazySource(source) ? source.entry.description : source.metadata.description;
+    // Cache for lazily activated skill (Tier 2)
+    let activatedSkill = isLazySource(source) ? null : source;
     return {
-        name: skill.id,
+        name: skillId,
         source: 'plugin',
         intent: 'AGENT',
-        description: skill.metadata.description,
+        description,
         riskLevel: 'medium',
         sideEffects: ['process', 'fs_read'],
         concurrency: 'serial_only',
@@ -21,8 +64,42 @@ export function skillToToolSpec(skill) {
             status: z.string(),
         }),
         executor: async (input, ctx) => {
-            const runner = new MicroTaskRunner(skill);
-            const result = await runner.execute({ args: input.args || '' }, ctx);
+            if (isBridgeSkillExecDisabled()) {
+                const traceId = generateSkillTraceId(skillId);
+                const argsHash = hashSkillArgs(input.args || '');
+                emitSkillAuditEvent({
+                    type: 'SKILL_EXECUTION_DENIED',
+                    skillId,
+                    route: 'tool-bridge',
+                    runnerClass: 'MicroTaskRunner',
+                    commandCount: 0,
+                    authorizationMode: 'blocking',
+                    argsHash,
+                    traceId,
+                    denyReason: 'BRIDGE_KILL_SWITCH',
+                    denySource: 'env:SALMONLOOP_DISABLE_BRIDGE_SKILL_EXEC',
+                });
+                const logger = tryGetLogger();
+                logger?.warn(`Bridge skill execution denied by kill-switch for skill "${skillId}" (traceId=${traceId})`);
+                return { prompt: '', status: 'DENIED' };
+            }
+            // Tier 2 activation: load full skill content on first invocation
+            if (!activatedSkill) {
+                const lazySource = source;
+                activatedSkill = await lazySource.loader.activateSkill(lazySource.entry.id);
+            }
+            // Lazily read the router from the box — it is populated after filtering.
+            const toolRouter = routerBox.router;
+            if (!toolRouter) {
+                throw new Error(`ToolRouter not yet initialized for skill "${skillId}"`);
+            }
+            const result = await executeSkill({
+                skill: activatedSkill,
+                argsText: input.args || '',
+                toolRouter,
+                toolCtx: ctx,
+                route: 'tool-bridge',
+            });
             return {
                 prompt: result.injectedPrompt,
                 status: result.status,

package/dist/core/skills/discovery.js

@@ -0,0 +1,94 @@
+import { text } from '../../locales/index.js';
+import { getLogger } from '../observability/logger.js';
+/**
+ * Check whether a file path matches a glob-like pattern.
+ *
+ * Supports:
+ * - `**` to match any number of path segments
+ * - `*` to match any characters within a single path segment
+ * - Literal path matching
+ *
+ * @param filePath - The file path to test (forward-slash normalized)
+ * @param pattern - The glob pattern to match against
+ * @returns true if the file path matches the pattern
+ */
+export function matchGlob(filePath, pattern) {
+    // Normalize separators to forward slash for consistent matching
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    const normalizedPattern = pattern.replace(/\\/g, '/');
+    // Build regex from glob pattern character by character
+    let regexStr = '';
+    let i = 0;
+    while (i < normalizedPattern.length) {
+        const ch = normalizedPattern[i];
+        if (ch === '*' && normalizedPattern[i + 1] === '*') {
+            // ** — match any number of path segments (including zero)
+            // Consume optional trailing slash: **/ matches zero-or-more dirs
+            i += 2;
+            if (normalizedPattern[i] === '/') {
+                i++;
+                // `**/` matches zero or more directory segments
+                regexStr += '(?:.+/)?';
+            }
+            else {
+                // `**` at end matches everything
+                regexStr += '.*';
+            }
+        }
+        else if (ch === '*') {
+            // * — match any characters except /
+            regexStr += '[^/]*';
+            i++;
+        }
+        else {
+            // Escape regex special characters for literal match
+            regexStr += ch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            i++;
+        }
+    }
+    const regex = new RegExp(`^${regexStr}$`);
+    return regex.test(normalizedPath);
+}
+/**
+ * Signal-based skill discovery watcher.
+ *
+ * Does NOT use fs.watch — instead provides methods that can be called
+ * when file operations happen. The caller handles the event source.
+ *
+ * Supports:
+ * - Re-scanning search paths for newly added skill directories (Requirement 7.1)
+ *
+ * @see Requirements 7.1, 7.2
+ */
+export class SkillDiscoveryWatcher {
+    /** Known skill ids from the last catalog snapshot. */
+    knownIds = new Set();
+    constructor(initialCatalog) {
+        for (const entry of initialCatalog) {
+            this.knownIds.add(entry.id);
+        }
+    }
+    /**
+     * Accept a refreshed catalog and return entries that are new
+     * (not previously known).
+     *
+     * Call this after re-scanning search paths (e.g. via SkillLoader.loadCatalog())
+     * when a file-operation signal indicates new skill directories may exist.
+     *
+     * @param refreshedCatalog - The full catalog from a fresh scan
+     * @returns Newly discovered catalog entries not in the previous snapshot
+     * @see Requirement 7.1
+     */
+    refreshCatalog(refreshedCatalog) {
+        const newEntries = [];
+        for (const entry of refreshedCatalog) {
+            if (!this.knownIds.has(entry.id)) {
+                newEntries.push(entry);
+                this.knownIds.add(entry.id);
+                getLogger().info(text.skills.newSkillDiscovered(entry.id, entry.location));
+            }
+        }
+        return newEntries;
+    }
+}
+//# sourceMappingURL=discovery.js.map

package/dist/core/skills/feature-flags.js

@@ -0,0 +1,52 @@
+/**
+ * Centralized feature flags for the skills subsystem.
+ *
+ * Provides rollout control over bridge execution.
+ *
+ * @see Requirements 11.4
+ */
+import { tryGetLogger } from '../observability/logger.js';
+// ---------------------------------------------------------------------------
+// Env-var helpers
+// ---------------------------------------------------------------------------
+/**
+ * Parse a boolean-ish env var value.
+ * Returns `true` for 'true'/'1', `false` for 'false'/'0', or the
+ * provided `fallback` when the value is undefined/empty.
+ */
+function parseBoolEnv(value, fallback) {
+    if (value === 'true' || value === '1')
+        return true;
+    if (value === 'false' || value === '0')
+        return false;
+    return fallback;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Read all skill-related feature flags from environment variables.
+ *
+ * The function is intentionally pure (no caching) so that tests can
+ * manipulate `process.env` between calls and observe the effect.
+ *
+ * @returns A snapshot of the current feature flag values
+ * @see Requirements 11.4
+ */
+export function getSkillFeatureFlags() {
+    const bridgeDefault = process.env.NODE_ENV !== 'development';
+    return {
+        bridgeDisabled: parseBoolEnv(process.env.SALMONLOOP_DISABLE_BRIDGE_SKILL_EXEC, bridgeDefault),
+    };
+}
+/**
+ * Log the current feature flag values at debug level.
+ *
+ * Useful at startup to record which flags are active for diagnostics.
+ */
+export function logSkillFeatureFlags() {
+    const flags = getSkillFeatureFlags();
+    const logger = tryGetLogger();
+    logger?.debug(`Skill feature flags: bridgeDisabled=${flags.bridgeDisabled}`);
+}
+//# sourceMappingURL=feature-flags.js.map

package/dist/core/skills/index.js

@@ -3,6 +3,6 @@ export * from './loader.js';
 export * from './parser.js';
 export * from './strategy.js';
 export * from './bridge.js';
-export { MicroTaskRunner } from './runtime/MicroTaskRunner.js';
+export * from './feature-flags.js';
 export * from './runtime/SkillRunner.js';
 //# sourceMappingURL=index.js.map