@a5c-ai/genty-platform 5.1.1-staging.0ad6ac75ae4a

package/dist/breakpoints/postures.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Status: Integrated with agent-platform breakpoint governance.
+ * Moved from @a5c-ai/babysitter-sdk.
+ * GAP-SEC-005: Approval Posture Model
+ *
+ * Defines the canonical safety ladder for action categories and provides
+ * posture resolution from breakpoint IDs.
+ *
+ * @module breakpoints/postures
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_POSTURES = void 0;
+exports.getPostureForCategory = getPostureForCategory;
+exports.resolvePostureFromBreakpointId = resolvePostureFromBreakpointId;
+/**
+ * Default postures per action category.
+ * The canonical safety ladder: read (permissive) -> write/network -> execute -> destroy/auth (locked).
+ */
+exports.DEFAULT_POSTURES = {
+    read: {
+        name: 'permissive',
+        allowAutoApprove: true,
+        minConsecutiveApprovalsForAutoN: 0,
+        requireExplicitRule: false,
+        requiredApproverLevel: 'any',
+    },
+    write: {
+        name: 'cautious',
+        allowAutoApprove: true,
+        minConsecutiveApprovalsForAutoN: 3,
+        requireExplicitRule: false,
+        requiredApproverLevel: 'any',
+    },
+    execute: {
+        name: 'guarded',
+        allowAutoApprove: true,
+        minConsecutiveApprovalsForAutoN: 5,
+        requireExplicitRule: true,
+        requiredApproverLevel: 'any',
+    },
+    destroy: {
+        name: 'locked',
+        allowAutoApprove: false,
+        minConsecutiveApprovalsForAutoN: -1,
+        requireExplicitRule: true,
+        requiredApproverLevel: 'owner',
+    },
+    network: {
+        name: 'cautious',
+        allowAutoApprove: true,
+        minConsecutiveApprovalsForAutoN: 3,
+        requireExplicitRule: false,
+        requiredApproverLevel: 'any',
+    },
+    auth: {
+        name: 'locked',
+        allowAutoApprove: false,
+        minConsecutiveApprovalsForAutoN: -1,
+        requireExplicitRule: true,
+        requiredApproverLevel: 'owner',
+    },
+};
+/**
+ * Get the posture for a category, optionally merged with overrides.
+ */
+function getPostureForCategory(category, overrides) {
+    const base = exports.DEFAULT_POSTURES[category];
+    if (!overrides)
+        return base;
+    return { ...base, ...overrides };
+}
+/**
+ * Prefix-to-category mapping for breakpoint ID namespace convention.
+ */
+const PREFIX_TO_CATEGORY = {
+    'read': 'read',
+    'write': 'write',
+    'exec': 'execute',
+    'execute': 'execute',
+    'destroy': 'destroy',
+    'delete': 'destroy',
+    'net': 'network',
+    'network': 'network',
+    'auth': 'auth',
+    'cred': 'auth',
+};
+/**
+ * Resolve an action category from a breakpoint ID's namespace prefix.
+ * Returns undefined for unknown prefixes (no posture enforcement applied).
+ *
+ * Convention: breakpointId format is `prefix.name` (e.g., `destroy.important-files`).
+ */
+function resolvePostureFromBreakpointId(breakpointId) {
+    const dotIndex = breakpointId.indexOf('.');
+    if (dotIndex === -1)
+        return undefined;
+    const prefix = breakpointId.substring(0, dotIndex);
+    return PREFIX_TO_CATEGORY[prefix];
+}

package/dist/compression/compaction.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 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.
+ */
+export type CompactionStrategy = "tool-output-summarization" | "iteration-digest";
+export interface CompactionConfig {
+    enabled: boolean;
+    /** Token budget threshold that triggers auto-compaction. */
+    autoCompactThreshold: number;
+    /** Strategies to apply, in order. */
+    strategies: CompactionStrategy[];
+    /** Maximum recent iterations to keep uncompacted. */
+    keepRecentIterations: number;
+    /** Target token reduction ratio for tool output summarization (0-1). */
+    toolOutputTargetReduction: number;
+}
+export interface CompactionResult {
+    strategy: CompactionStrategy;
+    tokensBefore: number;
+    tokensAfter: number;
+    itemsCompacted: number;
+    compactedAt: string;
+}
+export interface IterationDigest {
+    iteration: number;
+    runId: string;
+    summary: string;
+    resolvedEffects: string[];
+    durationSeconds: number;
+    timestamp: string;
+}
+export interface ToolOutputSummary {
+    /** Relative path from runsDir: runId/tasks/effectId/file */
+    relativePath: string;
+    /** Truncated/summarized content */
+    summary: string;
+    /** Original token count */
+    originalTokens: number;
+}
+export interface CompactionState {
+    operations: CompactionResult[];
+    iterationDigests: IterationDigest[];
+    toolOutputSummaries: ToolOutputSummary[];
+    totalTokensSaved: number;
+}
+interface JournalEvent {
+    type: string;
+    recordedAt: string;
+    data?: Record<string, unknown>;
+}
+export declare const DEFAULT_COMPACTION_CONFIG: CompactionConfig;
+export declare function getCompactionStatePath(stateDir: string, sessionId: string): string;
+export declare function getCompactionState(stateDir: string, sessionId: string): Promise<CompactionState>;
+/**
+ * Check whether auto-compaction should trigger.
+ */
+export declare function shouldAutoCompact(estimatedTokens: number, config: CompactionConfig): boolean;
+/**
+ * Build a digest from a set of journal events belonging to one iteration.
+ * Pure function.
+ */
+export declare function buildIterationDigest(runId: string, iteration: number, events: JournalEvent[]): IterationDigest;
+/**
+ * Run compaction strategies on a session.
+ * Reads journal/tasks as needed but only writes to the overlay file — never
+ * modifies originals.
+ */
+export declare function compactSession(stateDir: string, sessionId: string, runsDir: string, config?: CompactionConfig): Promise<CompactionResult[]>;
+/**
+ * Render iteration digests as markdown for prompt injection.
+ */
+export declare function renderCompactedHistory(state: CompactionState): string;
+export {};
+//# sourceMappingURL=compaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compaction.d.ts","sourceRoot":"","sources":["../../src/compression/compaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AASH,MAAM,MAAM,kBAAkB,GAC1B,2BAA2B,GAC3B,kBAAkB,CAAC;AAEvB,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,4DAA4D;IAC5D,oBAAoB,EAAE,MAAM,CAAC;IAC7B,qCAAqC;IACrC,UAAU,EAAE,kBAAkB,EAAE,CAAC;IACjC,qDAAqD;IACrD,oBAAoB,EAAE,MAAM,CAAC;IAC7B,wEAAwE;IACxE,yBAAyB,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,4DAA4D;IAC5D,YAAY,EAAE,MAAM,CAAC;IACrB,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,2BAA2B;IAC3B,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACpC,mBAAmB,EAAE,iBAAiB,EAAE,CAAC;IACzC,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAMD,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAMD,eAAO,MAAM,yBAAyB,EAAE,gBAMvC,CAAC;AAiDF,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAElF;AAED,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAEtG;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,eAAe,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAG5F;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,YAAY,EAAE,GACrB,eAAe,CAgCjB;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,MAAM,GAAE,gBAA4C,GACnD,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAkB7B;AAwID;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAQrE"}

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/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,8 @@
+export interface LoadedInstructions {
+    agentInstructions: string[];
+    systemPrompt?: string;
+    systemPromptMode: 'replace' | 'append' | 'none';
+    sources: string[];
+}
+export declare function loadInstructions(cwd: string): 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"}

package/dist/context/instructions.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadInstructions = loadInstructions;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+function loadInstructions(cwd) {
+    const agentInstructions = [];
+    const sources = [];
+    // 1. Global: ~/.genty/agent/AGENTS.md
+    const globalAgentsPath = (0, node_path_1.join)((0, node_os_1.homedir)(), '.genty', 'agent', 'AGENTS.md');
+    if ((0, node_fs_1.existsSync)(globalAgentsPath)) {
+        agentInstructions.push((0, node_fs_1.readFileSync)(globalAgentsPath, 'utf8'));
+        sources.push(globalAgentsPath);
+    }
+    // 2. Walk parent directories from cwd to root
+    const parentPaths = collectParentPaths(cwd);
+    for (const dir of parentPaths) {
+        const agentsPath = (0, node_path_1.join)(dir, 'AGENTS.md');
+        if ((0, node_fs_1.existsSync)(agentsPath)) {
+            agentInstructions.push((0, node_fs_1.readFileSync)(agentsPath, 'utf8'));
+            sources.push(agentsPath);
+        }
+        const gentyMdPath = (0, node_path_1.join)(dir, 'GENTY.md');
+        if ((0, node_fs_1.existsSync)(gentyMdPath)) {
+            agentInstructions.push((0, node_fs_1.readFileSync)(gentyMdPath, 'utf8'));
+            sources.push(gentyMdPath);
+        }
+    }
+    // 3. CWD itself (if not already included)
+    for (const name of ['AGENTS.md', 'GENTY.md']) {
+        const cwdPath = (0, node_path_1.join)(cwd, name);
+        if ((0, node_fs_1.existsSync)(cwdPath) && !sources.includes(cwdPath)) {
+            agentInstructions.push((0, node_fs_1.readFileSync)(cwdPath, 'utf8'));
+            sources.push(cwdPath);
+        }
+    }
+    // 4. SYSTEM.md
+    let systemPrompt;
+    let systemPromptMode = 'none';
+    const systemMdPath = (0, node_path_1.join)(cwd, 'SYSTEM.md');
+    if ((0, node_fs_1.existsSync)(systemMdPath)) {
+        const content = (0, node_fs_1.readFileSync)(systemMdPath, 'utf8');
+        const { mode, body } = parseSystemMd(content);
+        systemPrompt = body;
+        systemPromptMode = mode;
+        sources.push(systemMdPath);
+    }
+    return { agentInstructions, systemPrompt, systemPromptMode, sources };
+}
+function collectParentPaths(cwd) {
+    const paths = [];
+    let current = (0, node_path_1.resolve)(cwd);
+    const root = (0, node_path_1.parse)(current).root;
+    // Walk up, excluding cwd itself (added separately) and root
+    current = (0, node_path_1.dirname)(current);
+    while (current !== root && current !== (0, node_path_1.dirname)(current)) {
+        paths.unshift(current); // Parents first, then children
+        current = (0, node_path_1.dirname)(current);
+    }
+    return paths;
+}
+function parseSystemMd(content) {
+    const lines = content.split('\n');
+    let mode = 'append';
+    // Check for frontmatter
+    if (lines[0]?.trim() === '---') {
+        const endIdx = lines.indexOf('---', 1);
+        if (endIdx > 0) {
+            const frontmatter = lines.slice(1, endIdx).join('\n');
+            if (frontmatter.includes('mode: replace'))
+                mode = 'replace';
+            return { mode, body: lines.slice(endIdx + 1).join('\n').trim() };
+        }
+    }
+    return { mode, body: content.trim() };
+}