@a5c-ai/genty-platform 5.1.1-staging.00ceebd28cf2

package/dist/compression/compaction.js

@@ -0,0 +1,310 @@
+"use strict";
+/**
+ * Status: Integrated with agent-platform orchestration.
+ * Moved from @a5c-ai/babysitter-sdk.
+ * GAP-PERF-002: Session Compaction.
+ *
+ * Summarizes and condenses orchestration history to prevent context window
+ * overflow during long runs. Multiple strategies with auto-triggering
+ * based on token budget thresholds.
+ *
+ * Compacted data is stored as overlays — original journals and task artifacts
+ * are never modified.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_COMPACTION_CONFIG = void 0;
+exports.getCompactionStatePath = getCompactionStatePath;
+exports.getCompactionState = getCompactionState;
+exports.shouldAutoCompact = shouldAutoCompact;
+exports.buildIterationDigest = buildIterationDigest;
+exports.compactSession = compactSession;
+exports.renderCompactedHistory = renderCompactedHistory;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+exports.DEFAULT_COMPACTION_CONFIG = {
+    enabled: true,
+    autoCompactThreshold: 80_000,
+    strategies: ["tool-output-summarization", "iteration-digest"],
+    keepRecentIterations: 3,
+    toolOutputTargetReduction: 0.6,
+};
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function emptyCompactionState() {
+    return { operations: [], iterationDigests: [], toolOutputSummaries: [], totalTokensSaved: 0 };
+}
+async function readRaw(filePath) {
+    let raw;
+    try {
+        raw = await node_fs_1.promises.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return emptyCompactionState();
+        return emptyCompactionState();
+    }
+    try {
+        const data = JSON.parse(raw);
+        return {
+            operations: Array.isArray(data.operations) ? data.operations : [],
+            iterationDigests: Array.isArray(data.iterationDigests) ? data.iterationDigests : [],
+            toolOutputSummaries: Array.isArray(data.toolOutputSummaries) ? data.toolOutputSummaries : [],
+            totalTokensSaved: typeof data.totalTokensSaved === "number" ? data.totalTokensSaved : 0,
+        };
+    }
+    catch {
+        return emptyCompactionState();
+    }
+}
+async function writeRaw(filePath, data) {
+    const dir = path.dirname(filePath);
+    const tempPath = `${filePath}.tmp.${process.pid}`;
+    await node_fs_1.promises.mkdir(dir, { recursive: true });
+    await node_fs_1.promises.writeFile(tempPath, JSON.stringify(data, null, 2), "utf8");
+    await node_fs_1.promises.rename(tempPath, filePath);
+}
+/** Rough token estimate: ~4 chars per token. */
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+function getCompactionStatePath(stateDir, sessionId) {
+    return path.join(stateDir, `${sessionId}.compaction.json`);
+}
+async function getCompactionState(stateDir, sessionId) {
+    return readRaw(getCompactionStatePath(stateDir, sessionId));
+}
+/**
+ * Check whether auto-compaction should trigger.
+ */
+function shouldAutoCompact(estimatedTokens, config) {
+    if (!config.enabled)
+        return false;
+    return estimatedTokens > config.autoCompactThreshold;
+}
+/**
+ * Build a digest from a set of journal events belonging to one iteration.
+ * Pure function.
+ */
+function buildIterationDigest(runId, iteration, events) {
+    const resolvedEffects = [];
+    let earliestAt = "";
+    let latestAt = "";
+    for (const ev of events) {
+        if (!earliestAt || ev.recordedAt < earliestAt)
+            earliestAt = ev.recordedAt;
+        if (!latestAt || ev.recordedAt > latestAt)
+            latestAt = ev.recordedAt;
+        if (ev.type === "EFFECT_RESOLVED" && ev.data) {
+            const effectId = ev.data.effectId;
+            if (effectId)
+                resolvedEffects.push(effectId);
+        }
+    }
+    const durationSeconds = earliestAt && latestAt
+        ? (new Date(latestAt).getTime() - new Date(earliestAt).getTime()) / 1000
+        : 0;
+    const effectCount = resolvedEffects.length;
+    const eventTypes = [...new Set(events.map((e) => e.type))];
+    const summary = `Iteration ${iteration}: ${effectCount} effect(s) resolved, events: ${eventTypes.join(", ")}`;
+    return {
+        iteration,
+        runId,
+        summary,
+        resolvedEffects,
+        durationSeconds,
+        timestamp: latestAt || new Date().toISOString(),
+    };
+}
+/**
+ * Run compaction strategies on a session.
+ * Reads journal/tasks as needed but only writes to the overlay file — never
+ * modifies originals.
+ */
+async function compactSession(stateDir, sessionId, runsDir, config = exports.DEFAULT_COMPACTION_CONFIG) {
+    if (!config.enabled)
+        return [];
+    const overlayPath = getCompactionStatePath(stateDir, sessionId);
+    const state = await readRaw(overlayPath);
+    const results = [];
+    for (const strategy of config.strategies) {
+        const result = await applyStrategy(strategy, runsDir, config, state);
+        if (result) {
+            state.operations.push(result);
+            state.totalTokensSaved += result.tokensBefore - result.tokensAfter;
+            results.push(result);
+        }
+    }
+    await writeRaw(overlayPath, state);
+    return results;
+}
+async function applyStrategy(strategy, runsDir, config, state) {
+    const now = new Date().toISOString();
+    if (strategy === "iteration-digest") {
+        // Scan run directories for journal files, build digests for old iterations
+        const existingDigestIterations = new Set(state.iterationDigests.map((d) => `${d.runId}:${d.iteration}`));
+        let itemsCompacted = 0;
+        let tokensBefore = 0;
+        let tokensAfter = 0;
+        let runDirs;
+        try {
+            const entries = await node_fs_1.promises.readdir(runsDir, { withFileTypes: true });
+            runDirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+        }
+        catch {
+            return undefined;
+        }
+        for (const runDir of runDirs) {
+            const journalDir = path.join(runsDir, runDir, "journal");
+            let files;
+            try {
+                files = await node_fs_1.promises.readdir(journalDir);
+            }
+            catch {
+                continue;
+            }
+            // Group events by iteration (heuristic: each EFFECT_REQUESTED starts new iteration group)
+            const events = [];
+            for (const file of files.sort()) {
+                if (!file.endsWith(".json"))
+                    continue;
+                try {
+                    const raw = await node_fs_1.promises.readFile(path.join(journalDir, file), "utf8");
+                    events.push(JSON.parse(raw));
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (events.length === 0)
+                continue;
+            // Simple iteration grouping: split at RUN_CREATED or sequential grouping
+            const iterationSize = Math.max(1, Math.ceil(events.length / Math.max(1, config.keepRecentIterations + 1)));
+            const totalGroups = Math.ceil(events.length / iterationSize);
+            const compactableGroups = Math.max(0, totalGroups - config.keepRecentIterations);
+            for (let i = 0; i < compactableGroups; i++) {
+                const key = `${runDir}:${i + 1}`;
+                if (existingDigestIterations.has(key))
+                    continue;
+                const groupEvents = events.slice(i * iterationSize, (i + 1) * iterationSize);
+                const beforeTokens = estimateTokens(JSON.stringify(groupEvents));
+                const digest = buildIterationDigest(runDir, i + 1, groupEvents);
+                const afterTokens = estimateTokens(JSON.stringify(digest));
+                state.iterationDigests.push(digest);
+                tokensBefore += beforeTokens;
+                tokensAfter += afterTokens;
+                itemsCompacted++;
+            }
+        }
+        if (itemsCompacted === 0)
+            return undefined;
+        return { strategy, tokensBefore, tokensAfter, itemsCompacted, compactedAt: now };
+    }
+    if (strategy === "tool-output-summarization") {
+        // Scan task directories for large stdout/stderr, create summarized overlays
+        let itemsCompacted = 0;
+        let tokensBefore = 0;
+        let tokensAfter = 0;
+        let runDirs;
+        try {
+            const entries = await node_fs_1.promises.readdir(runsDir, { withFileTypes: true });
+            runDirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+        }
+        catch {
+            return undefined;
+        }
+        for (const runDir of runDirs) {
+            const tasksDir = path.join(runsDir, runDir, "tasks");
+            let taskDirs;
+            try {
+                const entries = await node_fs_1.promises.readdir(tasksDir, { withFileTypes: true });
+                taskDirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+            }
+            catch {
+                continue;
+            }
+            for (const taskDir of taskDirs) {
+                for (const file of ["stdout.txt", "stderr.txt"]) {
+                    const filePath = path.join(tasksDir, taskDir, file);
+                    try {
+                        const content = await node_fs_1.promises.readFile(filePath, "utf8");
+                        const beforeTokens = estimateTokens(content);
+                        if (beforeTokens < 200)
+                            continue; // Skip small outputs
+                        const relativePath = `${runDir}/tasks/${taskDir}/${file}`;
+                        // Skip if already summarized
+                        if (state.toolOutputSummaries.some((s) => s.relativePath === relativePath))
+                            continue;
+                        const targetLength = Math.ceil(content.length * (1 - config.toolOutputTargetReduction));
+                        const truncated = content.slice(0, targetLength) + "\n... [compacted]";
+                        const afterTokens = estimateTokens(truncated);
+                        state.toolOutputSummaries.push({
+                            relativePath,
+                            summary: truncated,
+                            originalTokens: beforeTokens,
+                        });
+                        tokensBefore += beforeTokens;
+                        tokensAfter += afterTokens;
+                        itemsCompacted++;
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+        }
+        if (itemsCompacted === 0)
+            return undefined;
+        return { strategy, tokensBefore, tokensAfter, itemsCompacted, compactedAt: now };
+    }
+    return undefined;
+}
+/**
+ * Render iteration digests as markdown for prompt injection.
+ */
+function renderCompactedHistory(state) {
+    if (state.iterationDigests.length === 0)
+        return "";
+    const lines = state.iterationDigests.map((d) => `- **Iter ${d.iteration}** (${d.runId}): ${d.summary} [${d.durationSeconds.toFixed(1)}s]`);
+    return `## Compacted History\n\n${lines.join("\n")}\n\n_${state.totalTokensSaved} tokens saved across ${state.operations.length} compaction(s)._`;
+}

package/dist/compression/compactionStrategy.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Compaction Strategy (GAP-PERF-002).
+ *
+ * Higher-level compaction strategy selection and auto-compaction triggers.
+ * Complements the existing compaction.ts with strategy-based compression
+ * targeting and message-count-aware auto-compact recommendations.
+ */
+/** Compaction aggressiveness level. */
+export type CompactionStrategyLevel = "aggressive" | "balanced" | "conservative";
+/** Metrics captured from a compaction pass. */
+export interface CompactionMetrics {
+    /** Token count of input (pre-compaction). */
+    inputTokens: number;
+    /** Token count of output (post-compaction). */
+    outputTokens: number;
+    /** Ratio of output to input (0-1, lower = more compressed). */
+    compressionRatio: number;
+    /** Wall-clock duration of the compaction pass in milliseconds. */
+    durationMs: number;
+}
+/**
+ * Returns the target compression ratio for a given strategy.
+ *
+ * - aggressive  → 0.3  (keep 30% of tokens)
+ * - balanced    → 0.5  (keep 50% of tokens)
+ * - conservative → 0.7  (keep 70% of tokens)
+ */
+export declare function getCompressionTarget(strategy: CompactionStrategyLevel): number;
+/**
+ * Determines whether auto-compaction should be triggered based on
+ * current message count, estimated token usage, and the chosen strategy.
+ *
+ * Returns true when either threshold (message count OR token estimate)
+ * is exceeded.
+ */
+export declare function shouldAutoCompact(messageCount: number, tokenEstimate: number, strategy: CompactionStrategyLevel): boolean;
+//# sourceMappingURL=compactionStrategy.d.ts.map

package/dist/compression/compactionStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compactionStrategy.d.ts","sourceRoot":"","sources":["../../src/compression/compactionStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,uCAAuC;AACvC,MAAM,MAAM,uBAAuB,GAAG,YAAY,GAAG,UAAU,GAAG,cAAc,CAAC;AAEjF,+CAA+C;AAC/C,MAAM,WAAW,iBAAiB;IAChC,6CAA6C;IAC7C,WAAW,EAAE,MAAM,CAAC;IACpB,+CAA+C;IAC/C,YAAY,EAAE,MAAM,CAAC;IACrB,+DAA+D;IAC/D,gBAAgB,EAAE,MAAM,CAAC;IACzB,kEAAkE;IAClE,UAAU,EAAE,MAAM,CAAC;CACpB;AAYD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,uBAAuB,GAAG,MAAM,CAE9E;AAgBD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,uBAAuB,GAChC,OAAO,CAGT"}

package/dist/compression/compactionStrategy.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Compaction Strategy (GAP-PERF-002).
+ *
+ * Higher-level compaction strategy selection and auto-compaction triggers.
+ * Complements the existing compaction.ts with strategy-based compression
+ * targeting and message-count-aware auto-compact recommendations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompressionTarget = getCompressionTarget;
+exports.shouldAutoCompact = shouldAutoCompact;
+// ---------------------------------------------------------------------------
+// Strategy → target ratio mapping
+// ---------------------------------------------------------------------------
+const STRATEGY_TARGETS = {
+    aggressive: 0.3,
+    balanced: 0.5,
+    conservative: 0.7,
+};
+/**
+ * Returns the target compression ratio for a given strategy.
+ *
+ * - aggressive  → 0.3  (keep 30% of tokens)
+ * - balanced    → 0.5  (keep 50% of tokens)
+ * - conservative → 0.7  (keep 70% of tokens)
+ */
+function getCompressionTarget(strategy) {
+    return STRATEGY_TARGETS[strategy];
+}
+// ---------------------------------------------------------------------------
+// Auto-compaction recommendation
+// ---------------------------------------------------------------------------
+/**
+ * Thresholds per strategy for triggering auto-compaction.
+ * More aggressive strategies trigger sooner.
+ */
+const AUTO_COMPACT_THRESHOLDS = {
+    aggressive: { messageCount: 20, tokenEstimate: 40_000 },
+    balanced: { messageCount: 50, tokenEstimate: 80_000 },
+    conservative: { messageCount: 100, tokenEstimate: 120_000 },
+};
+/**
+ * Determines whether auto-compaction should be triggered based on
+ * current message count, estimated token usage, and the chosen strategy.
+ *
+ * Returns true when either threshold (message count OR token estimate)
+ * is exceeded.
+ */
+function shouldAutoCompact(messageCount, tokenEstimate, strategy) {
+    const thresholds = AUTO_COMPACT_THRESHOLDS[strategy];
+    return messageCount >= thresholds.messageCount || tokenEstimate >= thresholds.tokenEstimate;
+}

package/dist/compression/compressionFamilies.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Context compression families (GAP-PROMPT-007).
+ *
+ * Groups messages by role/type and applies family-specific compression
+ * strategies ranging from aggressive (tool results) to minimal (system).
+ */
+export type CompressionStrategy = 'aggressive' | 'moderate' | 'conservative' | 'minimal';
+export type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
+export interface CompressionFamily {
+    id: string;
+    name: string;
+    strategy: CompressionStrategy;
+    /** Which message roles/types this family applies to. */
+    applicableTo: MessageRole[];
+    /** Custom compression function. Receives content, returns compressed content. */
+    compressionFn: (content: string) => string;
+}
+export interface CompressibleMessage {
+    role: MessageRole;
+    content: string;
+    /** Optional sub-type like 'thinking', 'tool-result', 'conversation'. */
+    type?: string;
+}
+export declare const BUILT_IN_FAMILIES: readonly CompressionFamily[];
+/**
+ * Select the best compression family for a given message.
+ *
+ * Priority:
+ *  1. 'tool' role messages → tool-results (aggressive)
+ *  2. Assistant messages with type 'thinking' → thinking (moderate)
+ *  3. User/assistant conversation → conversation (conservative)
+ *  4. System → system (minimal)
+ */
+export declare function selectFamily(message: CompressibleMessage): CompressionFamily;
+/**
+ * Apply a compression family's strategy to content.
+ */
+export declare function applyFamilyCompression(family: CompressionFamily, content: string): string;
+//# sourceMappingURL=compressionFamilies.d.ts.map

package/dist/compression/compressionFamilies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compressionFamilies.d.ts","sourceRoot":"","sources":["../../src/compression/compressionFamilies.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,MAAM,MAAM,mBAAmB,GAAG,YAAY,GAAG,UAAU,GAAG,cAAc,GAAG,SAAS,CAAC;AAEzF,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;AAEnE,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,wDAAwD;IACxD,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,iFAAiF;IACjF,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;CAC5C;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,wEAAwE;IACxE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAwDD,eAAO,MAAM,iBAAiB,EAAE,SAAS,iBAAiB,EA6BzD,CAAC;AAMF;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,iBAAiB,CAY5E;AAMD;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEzF"}

package/dist/compression/compressionFamilies.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Context compression families (GAP-PROMPT-007).
+ *
+ * Groups messages by role/type and applies family-specific compression
+ * strategies ranging from aggressive (tool results) to minimal (system).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILT_IN_FAMILIES = void 0;
+exports.selectFamily = selectFamily;
+exports.applyFamilyCompression = applyFamilyCompression;
+// ---------------------------------------------------------------------------
+// Built-in compression functions
+// ---------------------------------------------------------------------------
+/**
+ * Aggressive: collapse repeated whitespace, remove blank lines, truncate
+ * long outputs to first/last N lines with a summary marker.
+ */
+function compressAggressive(content) {
+    const lines = content.split('\n').filter((l) => l.trim().length > 0);
+    if (lines.length <= 20) {
+        return lines.join('\n');
+    }
+    const head = lines.slice(0, 8);
+    const tail = lines.slice(-8);
+    const omitted = lines.length - 16;
+    return [...head, `[... ${omitted} lines omitted ...]`, ...tail].join('\n');
+}
+/**
+ * Moderate: collapse repeated whitespace and trim very long lines.
+ */
+function compressModerate(content) {
+    return content
+        .split('\n')
+        .map((line) => {
+        const trimmed = line.trimEnd();
+        if (trimmed.length > 500) {
+            return trimmed.slice(0, 497) + '...';
+        }
+        return trimmed;
+    })
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n');
+}
+/**
+ * Conservative: only collapse excessive blank lines.
+ */
+function compressConservative(content) {
+    return content.replace(/\n{4,}/g, '\n\n\n');
+}
+/**
+ * Minimal: pass through unchanged.
+ */
+function compressMinimal(content) {
+    return content;
+}
+// ---------------------------------------------------------------------------
+// Built-in families
+// ---------------------------------------------------------------------------
+exports.BUILT_IN_FAMILIES = [
+    {
+        id: 'tool-results',
+        name: 'Tool Results',
+        strategy: 'aggressive',
+        applicableTo: ['tool'],
+        compressionFn: compressAggressive,
+    },
+    {
+        id: 'thinking',
+        name: 'Thinking',
+        strategy: 'moderate',
+        applicableTo: ['assistant'],
+        compressionFn: compressModerate,
+    },
+    {
+        id: 'conversation',
+        name: 'Conversation',
+        strategy: 'conservative',
+        applicableTo: ['user', 'assistant'],
+        compressionFn: compressConservative,
+    },
+    {
+        id: 'system',
+        name: 'System',
+        strategy: 'minimal',
+        applicableTo: ['system'],
+        compressionFn: compressMinimal,
+    },
+];
+// ---------------------------------------------------------------------------
+// selectFamily
+// ---------------------------------------------------------------------------
+/**
+ * Select the best compression family for a given message.
+ *
+ * Priority:
+ *  1. 'tool' role messages → tool-results (aggressive)
+ *  2. Assistant messages with type 'thinking' → thinking (moderate)
+ *  3. User/assistant conversation → conversation (conservative)
+ *  4. System → system (minimal)
+ */
+function selectFamily(message) {
+    if (message.role === 'tool') {
+        return exports.BUILT_IN_FAMILIES[0]; // tool-results
+    }
+    if (message.role === 'assistant' && message.type === 'thinking') {
+        return exports.BUILT_IN_FAMILIES[1]; // thinking
+    }
+    if (message.role === 'system') {
+        return exports.BUILT_IN_FAMILIES[3]; // system
+    }
+    // Default: conversation
+    return exports.BUILT_IN_FAMILIES[2]; // conversation
+}
+// ---------------------------------------------------------------------------
+// applyFamilyCompression
+// ---------------------------------------------------------------------------
+/**
+ * Apply a compression family's strategy to content.
+ */
+function applyFamilyCompression(family, content) {
+    return family.compressionFn(content);
+}

package/dist/context/dynamic.d.ts

@@ -0,0 +1,16 @@
+import type { ContextInjection, ContextProvider, TurnContext } from '@a5c-ai/genty-core/extensions';
+export interface DynamicContextPipeline {
+    providers: ContextProvider[];
+    addProvider(provider: ContextProvider): void;
+    removeProvider(id: string): void;
+    collectInjections(turnCtx: TurnContext): Promise<ContextInjection[]>;
+    applyInjections(injections: ContextInjection[], messages: Array<{
+        role: string;
+        content: string;
+    }>): Array<{
+        role: string;
+        content: string;
+    }>;
+}
+export declare function createDynamicContextPipeline(): DynamicContextPipeline;
+//# sourceMappingURL=dynamic.d.ts.map

package/dist/context/dynamic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic.d.ts","sourceRoot":"","sources":["../../src/context/dynamic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAEpG,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,WAAW,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI,CAAC;IAC7C,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IACrE,eAAe,CAAC,UAAU,EAAE,gBAAgB,EAAE,EAAE,QAAQ,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC/I;AAED,wBAAgB,4BAA4B,IAAI,sBAAsB,CAwDrE"}

package/dist/context/dynamic.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDynamicContextPipeline = createDynamicContextPipeline;
+function createDynamicContextPipeline() {
+    const providers = [];
+    return {
+        providers,
+        addProvider(provider) {
+            providers.push(provider);
+        },
+        removeProvider(id) {
+            const idx = providers.findIndex(p => p.id === id);
+            if (idx >= 0)
+                providers.splice(idx, 1);
+        },
+        async collectInjections(turnCtx) {
+            const results = [];
+            for (const provider of providers) {
+                try {
+                    const injection = await provider.provide(turnCtx);
+                    results.push(injection);
+                }
+                catch {
+                    // Provider errors must not block the turn
+                }
+            }
+            return results;
+        },
+        applyInjections(injections, messages) {
+            const result = [...messages];
+            let systemAppend = '';
+            for (const injection of injections) {
+                if (injection.messages) {
+                    const lastUserIdx = result.findLastIndex((m) => m.role === 'user');
+                    if (lastUserIdx >= 0) {
+                        result.splice(lastUserIdx, 0, ...injection.messages);
+                    }
+                    else {
+                        result.push(...injection.messages);
+                    }
+                }
+                if (injection.systemPromptAppend) {
+                    systemAppend += '\n' + injection.systemPromptAppend;
+                }
+            }
+            if (systemAppend && result.length > 0) {
+                const first = result[0];
+                if (first.role === 'system') {
+                    result[0] = { ...first, content: first.content + systemAppend };
+                }
+            }
+            return result;
+        },
+    };
+}

package/dist/context/instructions.d.ts

@@ -0,0 +1,15 @@
+export interface LoadedInstructions {
+    agentInstructions: string[];
+    systemPrompt?: string;
+    systemPromptMode: 'replace' | 'append' | 'none';
+    sources: string[];
+}
+export declare function loadInstructions(cwd: string): LoadedInstructions;
+export interface InstructionsLoadedEvent {
+    sources: string[];
+    agentInstructions: string[];
+    systemPrompt?: string;
+    systemPromptMode: 'replace' | 'append' | 'none';
+}
+export declare function loadInstructionsWithHook(cwd: string, emitEvent?: (event: InstructionsLoadedEvent) => Promise<void> | void): Promise<LoadedInstructions>;
+//# sourceMappingURL=instructions.d.ts.map

package/dist/context/instructions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instructions.d.ts","sourceRoot":"","sources":["../../src/context/instructions.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,kBAAkB;IACjC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAC;IAChD,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB,CAiDhE;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAC;CACjD;AAED,wBAAsB,wBAAwB,CAC5C,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,GACnE,OAAO,CAAC,kBAAkB,CAAC,CAkB7B"}