agentfootprint 1.0.0

package/dist/lib/instructions/InstructionRecorder.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * InstructionRecorder — tracks which LLM instructions fired and follow-up usage.
+ *
+ * Implements AgentRecorder so it plugs into the standard `.recorder()` API.
+ * Records per-tool instruction firings and follow-up accuracy for evaluation.
+ *
+ * @example
+ * ```typescript
+ * import { Agent, InstructionRecorder } from 'agentfootprint';
+ *
+ * const recorder = new InstructionRecorder();
+ * const agent = Agent.create({ provider })
+ *   .recorder(recorder)
+ *   .build();
+ *
+ * await agent.run('Check my order');
+ *
+ * console.log(recorder.getSummary());
+ * // {
+ * //   totalFired: 2,
+ * //   totalFollowUpsOffered: 1,
+ * //   byTool: {
+ * //     check_order: {
+ * //       instructions: { 'cancelled': { fired: 1, safety: false } },
+ * //       followUps: { 'get_trace': { offered: 1 } },
+ * //     }
+ * //   }
+ * // }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstructionRecorder = void 0;
+// ── Recorder ────────────────────────────────────────────────────────────
+class InstructionRecorder {
+    id;
+    firings = new Map();
+    followUps = new Map();
+    constructor(id = 'instruction-recorder') {
+        this.id = id;
+    }
+    /**
+     * Record instructions that fired for a tool invocation.
+     *
+     * Called by the agent loop after processInstructions() completes.
+     * Not an AgentRecorder hook — this is a dedicated method because
+     * instruction events don't map to the standard onLLMCall/onToolCall events.
+     */
+    recordFirings(toolId, fired) {
+        for (const instr of fired) {
+            // Track instruction firing
+            if (!this.firings.has(toolId))
+                this.firings.set(toolId, new Map());
+            const toolFirings = this.firings.get(toolId);
+            const existing = toolFirings.get(instr.id);
+            if (existing) {
+                existing.count++;
+            }
+            else {
+                toolFirings.set(instr.id, { count: 1, safety: instr.safety });
+            }
+            // Track follow-up offering
+            if (instr.resolvedFollowUp) {
+                if (!this.followUps.has(toolId))
+                    this.followUps.set(toolId, new Map());
+                const toolFollowUps = this.followUps.get(toolId);
+                const fuKey = instr.resolvedFollowUp.toolId;
+                const existingFu = toolFollowUps.get(fuKey);
+                if (existingFu) {
+                    existingFu.count++;
+                }
+                else {
+                    toolFollowUps.set(fuKey, { count: 1, toolId: fuKey });
+                }
+            }
+        }
+    }
+    /** Get summary of all instruction firings and follow-up offerings. */
+    getSummary() {
+        let totalFired = 0;
+        let totalFollowUpsOffered = 0;
+        const byTool = {};
+        // All tool IDs that have any activity
+        const allToolIds = new Set([...this.firings.keys(), ...this.followUps.keys()]);
+        for (const toolId of allToolIds) {
+            const instructions = {};
+            const followUps = {};
+            const toolFirings = this.firings.get(toolId);
+            if (toolFirings) {
+                for (const [instrId, data] of toolFirings) {
+                    instructions[instrId] = { fired: data.count, safety: data.safety };
+                    totalFired += data.count;
+                }
+            }
+            const toolFollowUps = this.followUps.get(toolId);
+            if (toolFollowUps) {
+                for (const [fuToolId, data] of toolFollowUps) {
+                    followUps[fuToolId] = { offered: data.count, toolId: data.toolId };
+                    totalFollowUpsOffered += data.count;
+                }
+            }
+            byTool[toolId] = { instructions, followUps };
+        }
+        return { totalFired, totalFollowUpsOffered, byTool };
+    }
+    /** Get firing count for a specific instruction on a specific tool. */
+    getFiringCount(toolId, instructionId) {
+        return this.firings.get(toolId)?.get(instructionId)?.count ?? 0;
+    }
+    /** Get all instruction IDs that fired for a tool. */
+    getFiredInstructionIds(toolId) {
+        const toolFirings = this.firings.get(toolId);
+        return toolFirings ? [...toolFirings.keys()] : [];
+    }
+    /** Serialize for inclusion in executor.getSnapshot().recorders. */
+    toSnapshot() {
+        return { name: 'Instructions', data: this.getSummary() };
+    }
+    clear() {
+        this.firings.clear();
+        this.followUps.clear();
+    }
+}
+exports.InstructionRecorder = InstructionRecorder;
+//# sourceMappingURL=InstructionRecorder.js.map

package/dist/lib/instructions/InstructionRecorder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstructionRecorder.js","sourceRoot":"","sources":["../../../src/lib/instructions/InstructionRecorder.ts"],"names":[],"mappings":"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"}

package/dist/lib/instructions/agentInstruction.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Agent-level Instruction type — conditional context injection across all 3 LLM API positions.
+ *
+ * Unlike tool-level `LLMInstruction` (fires on a specific tool result),
+ * an `AgentInstruction` fires based on accumulated Decision Scope state
+ * and can inject into system prompt, tools, AND tool response rules.
+ *
+ * Evaluated by the InstructionsToLLM subflow BEFORE the 3 API slots.
+ *
+ * Naming:
+ *   `activeWhen` (agent-level, reads decision scope) vs
+ *   `when` (tool-level, reads tool result context) — no collision.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineInstruction = exports.evaluateAgentInstructions = void 0;
+const isDevMode = () => typeof process !== 'undefined' && process.env?.['NODE_ENV'] !== 'production';
+// ── Evaluator ──────────────────────────────────────────────────────────
+/**
+ * Check if an instruction has at least one output (prompt, tools, or onToolResult).
+ */
+function hasOutputs(instr) {
+    return !!(instr.prompt || (instr.tools && instr.tools.length > 0) || (instr.onToolResult && instr.onToolResult.length > 0));
+}
+/**
+ * Evaluate agent-level instructions against the current decision scope.
+ *
+ * Returns categorized outputs for each of the 3 LLM API positions.
+ * Instructions are sorted by priority (lower = first), with safety
+ * instructions always sorted LAST (matching tool-level convention).
+ *
+ * Error handling follows the same pattern as tool-level instructions:
+ *   - Behavioral (safety: false): predicate throws → skip (fail-open)
+ *   - Safety (safety: true): predicate throws → fire (fail-closed)
+ *
+ * @example
+ * ```typescript
+ * const result = evaluateAgentInstructions(instructions, { orderStatus: 'denied' });
+ * // result.promptInjections → ['Handle denied orders with empathy.']
+ * // result.toolInjections → [processRefund, getTrace]
+ * // result.responseRules → [{ id: 'empathy', text: '...' }]
+ * // result.matchedIds → ['refund-handling']
+ * ```
+ */
+function evaluateAgentInstructions(instructions, decision) {
+    const empty = {
+        promptInjections: [],
+        toolInjections: [],
+        responseRules: [],
+        matchedIds: [],
+    };
+    if (!instructions || instructions.length === 0)
+        return empty;
+    // Sort by priority, safety instructions LAST (matching tool-level convention).
+    // Stable sort preserves registration order for ties.
+    const sorted = [...instructions].sort((a, b) => {
+        const aSafety = a.safety ?? false;
+        const bSafety = b.safety ?? false;
+        if (aSafety !== bSafety)
+            return aSafety ? 1 : -1;
+        return (a.priority ?? 0) - (b.priority ?? 0);
+    });
+    const promptInjections = [];
+    const toolInjections = [];
+    const responseRules = [];
+    const matchedIds = [];
+    const seenToolIds = new Set();
+    for (const instr of sorted) {
+        // Evaluate predicate
+        if (instr.activeWhen) {
+            try {
+                if (!instr.activeWhen(decision))
+                    continue;
+            }
+            catch {
+                if (instr.safety) {
+                    // Safety: fail-closed — fire when predicate errors
+                }
+                else {
+                    // Behavioral: fail-open — skip broken predicate
+                    continue;
+                }
+            }
+        }
+        // P0 review fix: warn in dev mode when safety instruction has no outputs
+        if (instr.safety && !hasOutputs(instr)) {
+            if (isDevMode()) {
+                console.warn(`[agentfootprint] Safety instruction '${instr.id}' matched but has no outputs (prompt, tools, or onToolResult). ` +
+                    `It will appear in matchedIds but inject nothing.`);
+            }
+        }
+        matchedIds.push(instr.id);
+        if (instr.prompt) {
+            promptInjections.push(instr.prompt);
+        }
+        if (instr.tools) {
+            for (const tool of instr.tools) {
+                // Deduplicate by tool ID — first registration wins
+                if (!seenToolIds.has(tool.id)) {
+                    seenToolIds.add(tool.id);
+                    toolInjections.push(tool);
+                }
+            }
+        }
+        if (instr.onToolResult) {
+            responseRules.push(...instr.onToolResult);
+        }
+    }
+    return { promptInjections, toolInjections, responseRules, matchedIds };
+}
+exports.evaluateAgentInstructions = evaluateAgentInstructions;
+// ── Factory ────────────────────────────────────────────────────────────
+/**
+ * Create a validated agent-level instruction.
+ *
+ * This is the preferred way to create instructions — validates the `id` field
+ * at build time and provides good TypeScript inference for the decision type.
+ *
+ * @example
+ * ```typescript
+ * interface MyDecision {
+ *   orderStatus: 'pending' | 'denied' | null;
+ *   riskLevel: 'low' | 'high';
+ * }
+ *
+ * const refund = defineInstruction<MyDecision>({
+ *   id: 'refund-handling',
+ *   activeWhen: (d) => d.orderStatus === 'denied',
+ *   prompt: 'Handle denied orders with empathy.',
+ *   tools: [processRefund, getTrace],
+ *   onToolResult: [
+ *     { id: 'empathy', text: 'Do NOT promise reversal.' },
+ *   ],
+ * });
+ * ```
+ */
+function defineInstruction(config) {
+    if (!config.id) {
+        throw new Error('defineInstruction: id is required');
+    }
+    return config;
+}
+exports.defineInstruction = defineInstruction;
+//# sourceMappingURL=agentInstruction.js.map

package/dist/lib/instructions/agentInstruction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentInstruction.js","sourceRoot":"","sources":["../../../src/lib/instructions/agentInstruction.ts"],"names":[],"mappings":"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"}

package/dist/lib/instructions/buildInstructionsToLLMSubflow.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * InstructionsToLLM subflow — evaluates agent-level instructions before the 3 API slots.
+ *
+ * Runs once per loop iteration (Dynamic pattern) or once before the loop (Regular).
+ * Reads the current Decision Scope, evaluates all registered instructions'
+ * `activeWhen` predicates, and outputs categorized injections for each slot:
+ *
+ *   promptInjections → consumed by SystemPrompt slot
+ *   toolInjections   → consumed by Tools slot
+ *   responseRules    → consumed by tool execution subflow
+ *
+ * The instruction registry is baked into the subflow via closure at build time.
+ * This is a footprintjs flowchart subflow — visible in narrative/BTS.
+ *
+ * Loop position:
+ *   Seed → [InstructionsToLLM] → [SystemPrompt] → [Messages] → [Tools] → ...
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInstructionsToLLMSubflow = void 0;
+const footprintjs_1 = require("footprintjs");
+const agentInstruction_1 = require("./agentInstruction");
+/**
+ * Build the InstructionsToLLM subflow from a registry of agent-level instructions.
+ *
+ * The instructions array is captured by closure — immutable after build (shallow freeze).
+ * The subflow reads `scope.decision` (from parent inputMapper) and writes
+ * the categorized outputs for downstream slots to consume.
+ *
+ * **Parent state requirements:** The parent chart's `inputMapper` MUST map the
+ * `decision` field. If `decision` is missing (undefined), all instructions with
+ * `activeWhen` predicates will evaluate against `undefined` — behavioral predicates
+ * will throw and be skipped (fail-open), safety predicates will fire (fail-closed).
+ *
+ * The `outputMapper` should map the 3 output fields back to the parent state:
+ * `promptInjections`, `toolInjections`, `responseRules` (and optionally
+ * `matchedInstructions` for narrative enrichment).
+ *
+ * @param instructions - Agent-level instructions registered via `.instruction()`.
+ *   Empty array is valid (subflow becomes a no-op pass-through).
+ *
+ * @example
+ * ```typescript
+ * const subflow = buildInstructionsToLLMSubflow([refundInstruction, complianceInstruction]);
+ *
+ * // Mount in agent loop (parent state must include matching fields):
+ * builder.addSubFlowChartNext('sf-instructions-to-llm', subflow, 'InstructionsToLLM', {
+ *   inputMapper: (parent) => ({ decision: parent.decision }),
+ *   outputMapper: (sf) => ({
+ *     promptInjections: sf.promptInjections,
+ *     toolInjections: sf.toolInjections,
+ *     responseRules: sf.responseRules,
+ *     matchedInstructions: sf.matchedInstructions,
+ *   }),
+ * });
+ * ```
+ */
+function buildInstructionsToLLMSubflow(instructions) {
+    // Freeze the instruction list — no mutations after build.
+    // Note: shallow freeze — individual instruction objects are readonly-typed
+    // but not deeply frozen. This is sufficient since TypeScript enforces readonly.
+    const frozenInstructions = Object.freeze([...instructions]);
+    return (0, footprintjs_1.flowChart)('EvaluateInstructions', (scope) => {
+        // Read decision scope from parent. If missing (inputMapper didn't map it),
+        // pass through as-is — predicates will see undefined and fail-open/closed
+        // according to their safety flag.
+        const decision = scope.decision;
+        const result = (0, agentInstruction_1.evaluateAgentInstructions)(frozenInstructions, decision);
+        scope.promptInjections = [...result.promptInjections];
+        // Convert ToolDefinition → LLMToolDescription (strip handler for LLM consumption)
+        scope.toolInjections = result.toolInjections.map((t) => ({
+            name: t.id,
+            description: t.description,
+            inputSchema: t.inputSchema,
+        }));
+        scope.responseRules = [...result.responseRules];
+        // Narrative enrichment — which instructions fired and why
+        if (result.matchedIds.length > 0) {
+            scope.matchedInstructions = `${result.matchedIds.length} matched: ${result.matchedIds.join(', ')}`;
+        }
+        else {
+            scope.matchedInstructions = 'none matched';
+        }
+    }, 'evaluate-instructions', undefined, 'Evaluate agent instructions against Decision Scope').build();
+}
+exports.buildInstructionsToLLMSubflow = buildInstructionsToLLMSubflow;
+//# sourceMappingURL=buildInstructionsToLLMSubflow.js.map

package/dist/lib/instructions/buildInstructionsToLLMSubflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildInstructionsToLLMSubflow.js","sourceRoot":"","sources":["../../../src/lib/instructions/buildInstructionsToLLMSubflow.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;;;AAEH,6CAAwC;AAKxC,yDAA+D;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,SAAgB,6BAA6B,CAC3C,YAAyC;IAEzC,0DAA0D;IAC1D,2EAA2E;IAC3E,gFAAgF;IAChF,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;IAE5D,OAAO,IAAA,uBAAS,EACd,sBAAsB,EACtB,CAAC,KAAyC,EAAE,EAAE;QAC5C,2EAA2E;QAC3E,0EAA0E;QAC1E,kCAAkC;QAClC,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QAChC,MAAM,MAAM,GAAG,IAAA,4CAAyB,EAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;QAEvE,KAAK,CAAC,gBAAgB,GAAG,CAAC,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;QACtD,kFAAkF;QAClF,KAAK,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAsB,EAAE,CAAC,CAAC;YAC3E,IAAI,EAAE,CAAC,CAAC,EAAE;YACV,WAAW,EAAE,CAAC,CAAC,WAAW;YAC1B,WAAW,EAAE,CAAC,CAAC,WAAW;SAC3B,CAAC,CAAC,CAAC;QACJ,KAAK,CAAC,aAAa,GAAG,CAAC,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;QAEhD,0DAA0D;QAC1D,IAAI,MAAM,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACjC,KAAK,CAAC,mBAAmB,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,MAAM,aAAa,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACrG,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,mBAAmB,GAAG,cAAc,CAAC;QAC7C,CAAC;IACH,CAAC,EACD,uBAAuB,EACvB,SAAS,EACT,oDAAoD,CACrD,CAAC,KAAK,EAAE,CAAC;AACZ,CAAC;AArCD,sEAqCC"}

package/dist/lib/instructions/evaluator.js

@@ -0,0 +1,202 @@
+"use strict";
+/**
+ * Instruction evaluator — matches instructions against tool results.
+ *
+ * Evaluates `when` predicates, sorts by priority, and orders for injection:
+ *   1. Follow-up bindings (structured actions)
+ *   2. Behavioral instructions (free text guidance)
+ *   3. Safety instructions LAST (closest to LLM generation = highest attention)
+ *
+ * Predicates that throw are skipped with a warning (fail-open for behavioral,
+ * fail-closed for safety). This is the defensive behavior — a broken predicate
+ * should not prevent the agent from working, but safety instructions should
+ * fail-closed (fire when in doubt).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyInstructionOverrides = exports.mergeRuntimeInstructions = exports.evaluateInstructions = void 0;
+// ── Evaluator ───────────────────────────────────────────────────────────
+/**
+ * Evaluate build-time instructions against a tool result context.
+ *
+ * Returns resolved instructions sorted for injection:
+ *   1. Non-safety with follow-up only (structured actions first)
+ *   2. Non-safety with inject (behavioral guidance)
+ *   3. Safety instructions (LAST = highest attention weight)
+ *
+ * Within each group, sorted by priority (lower = first), then array order.
+ *
+ * @example
+ * ```typescript
+ * const fired = evaluateInstructions(tool.instructions, {
+ *   content: { status: 'denied', traceId: 'tr_8f3a' },
+ *   error: undefined,
+ *   latencyMs: 42,
+ *   input: { applicantId: 'a-1' },
+ *   toolId: 'evaluate_loan',
+ * });
+ *
+ * // fired: [{ id: 'denial-empathy', text: '...', resolvedFollowUp: {...} }]
+ * ```
+ */
+function evaluateInstructions(instructions, ctx) {
+    if (!instructions || instructions.length === 0)
+        return [];
+    const matched = [];
+    for (const instr of instructions) {
+        // Evaluate predicate — skip on throw for behavioral, fire on throw for safety
+        if (instr.when) {
+            try {
+                if (!instr.when(ctx))
+                    continue; // predicate returned false
+            }
+            catch {
+                if (instr.safety) {
+                    // Safety: fail-closed — fire the instruction when predicate errors
+                    // Better to inject a safety instruction unnecessarily than to miss it
+                }
+                else {
+                    // Behavioral: fail-open — skip broken predicate
+                    continue;
+                }
+            }
+        }
+        // No `when` = unconditional — always fires
+        // Resolve follow-up params if present
+        let resolvedFollowUp;
+        if (instr.followUp) {
+            try {
+                const params = instr.followUp.params(ctx);
+                resolvedFollowUp = {
+                    toolId: instr.followUp.toolId,
+                    params,
+                    description: instr.followUp.description,
+                    condition: instr.followUp.condition,
+                    strict: instr.followUp.strict ?? false,
+                };
+            }
+            catch {
+                // If params resolution fails, skip the follow-up but keep the inject
+                resolvedFollowUp = undefined;
+            }
+        }
+        matched.push({
+            id: instr.id,
+            text: instr.text,
+            resolvedFollowUp,
+            safety: instr.safety ?? false,
+            priority: instr.priority ?? 0,
+        });
+    }
+    // Sort for injection order:
+    // 1. Non-safety sorted by priority (lower first), then array order (stable sort)
+    // 2. Safety instructions at the end (closest to generation = highest attention)
+    return matched.sort((a, b) => {
+        // Safety always after non-safety
+        if (a.safety !== b.safety)
+            return a.safety ? 1 : -1;
+        // Within same safety group, sort by priority
+        return a.priority - b.priority;
+    });
+}
+exports.evaluateInstructions = evaluateInstructions;
+/**
+ * Merge build-time resolved instructions with runtime instructions/followUps.
+ *
+ * Runtime instructions (from handler return) are appended after build-time
+ * behavioral instructions but before safety instructions.
+ *
+ * @example
+ * ```typescript
+ * const buildTime = evaluateInstructions(tool.instructions, ctx);
+ * const runtime = {
+ *   instructions: ['Service degraded. Set expectations.'],
+ *   followUps: [{ toolId: 'status_page', params: {}, description: '...', condition: '...' }],
+ * };
+ * const merged = mergeRuntimeInstructions(buildTime, runtime);
+ * ```
+ */
+function mergeRuntimeInstructions(buildTime, runtime) {
+    if (!runtime)
+        return buildTime;
+    const runtimeResolved = [];
+    // Runtime follow-ups
+    if (runtime.followUps) {
+        for (const fu of runtime.followUps) {
+            if (!fu.toolId || !fu.params)
+                continue; // validate required fields
+            runtimeResolved.push({
+                id: `runtime-followup-${fu.toolId}`,
+                resolvedFollowUp: {
+                    toolId: fu.toolId,
+                    params: fu.params,
+                    description: fu.description,
+                    condition: fu.condition,
+                    strict: fu.strict ?? false,
+                },
+                safety: false,
+                priority: 0,
+            });
+        }
+    }
+    // Runtime behavioral instructions
+    if (runtime.instructions) {
+        for (let i = 0; i < runtime.instructions.length; i++) {
+            runtimeResolved.push({
+                id: `runtime-text-${i}`,
+                text: runtime.instructions[i],
+                safety: false,
+                priority: 0,
+            });
+        }
+    }
+    // Merge: build-time non-safety → runtime → build-time safety
+    const nonSafety = buildTime.filter((r) => !r.safety);
+    const safety = buildTime.filter((r) => r.safety);
+    return [...nonSafety, ...runtimeResolved, ...safety];
+}
+exports.mergeRuntimeInstructions = mergeRuntimeInstructions;
+/**
+ * Apply agent-level overrides to a tool's instructions.
+ *
+ * Returns a new instruction array with overrides applied:
+ * 1. Suppress: remove instructions by ID
+ * 2. Replace: merge partial overrides into existing instructions by ID
+ * 3. Add: append new instructions at the end
+ *
+ * @example
+ * ```typescript
+ * const original = tool.instructions;
+ * const overridden = applyInstructionOverrides(original, {
+ *   suppress: ['low-stock'],
+ *   add: [{ id: 'premium-oos', when: ..., text: '...' }],
+ *   replace: { 'out-of-stock': { text: 'Suggest B2B channel.' } },
+ * });
+ * ```
+ */
+function applyInstructionOverrides(instructions, override) {
+    if (!instructions || instructions.length === 0) {
+        return [...(override.add ?? [])];
+    }
+    const suppressSet = new Set(override.suppress ?? []);
+    const replaceMap = override.replace ?? {};
+    // 1. Filter suppressed, then apply replacements
+    const result = [];
+    for (const instr of instructions) {
+        if (suppressSet.has(instr.id))
+            continue; // suppressed
+        const replacement = replaceMap[instr.id];
+        if (replacement) {
+            result.push({ ...instr, ...replacement, id: instr.id }); // merge, preserve ID
+        }
+        else {
+            result.push(instr);
+        }
+    }
+    // 2. Add new instructions
+    if (override.add) {
+        result.push(...override.add);
+    }
+    return result;
+}
+exports.applyInstructionOverrides = applyInstructionOverrides;
+//# sourceMappingURL=evaluator.js.map

package/dist/lib/instructions/evaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.js","sourceRoot":"","sources":["../../../src/lib/instructions/evaluator.ts"],"names":[],"mappings":"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"}

package/dist/lib/instructions/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInstructionsToLLMSubflow = exports.defineInstruction = exports.evaluateAgentInstructions = exports.PendingFollowUpManager = exports.defaultConditionMatcher = exports.InstructionRecorder = exports.previewInstructions = exports.processInstructions = exports.renderInstructions = exports.applyInstructionOverrides = exports.mergeRuntimeInstructions = exports.evaluateInstructions = exports.follow = exports.quickBind = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "quickBind", { enumerable: true, get: function () { return types_1.quickBind; } });
+Object.defineProperty(exports, "follow", { enumerable: true, get: function () { return types_1.follow; } });
+var evaluator_1 = require("./evaluator");
+Object.defineProperty(exports, "evaluateInstructions", { enumerable: true, get: function () { return evaluator_1.evaluateInstructions; } });
+Object.defineProperty(exports, "mergeRuntimeInstructions", { enumerable: true, get: function () { return evaluator_1.mergeRuntimeInstructions; } });
+Object.defineProperty(exports, "applyInstructionOverrides", { enumerable: true, get: function () { return evaluator_1.applyInstructionOverrides; } });
+var template_1 = require("./template");
+Object.defineProperty(exports, "renderInstructions", { enumerable: true, get: function () { return template_1.renderInstructions; } });
+var inject_1 = require("./inject");
+Object.defineProperty(exports, "processInstructions", { enumerable: true, get: function () { return inject_1.processInstructions; } });
+var preview_1 = require("./preview");
+Object.defineProperty(exports, "previewInstructions", { enumerable: true, get: function () { return preview_1.previewInstructions; } });
+var InstructionRecorder_1 = require("./InstructionRecorder");
+Object.defineProperty(exports, "InstructionRecorder", { enumerable: true, get: function () { return InstructionRecorder_1.InstructionRecorder; } });
+var strictFollowUp_1 = require("./strictFollowUp");
+Object.defineProperty(exports, "defaultConditionMatcher", { enumerable: true, get: function () { return strictFollowUp_1.defaultConditionMatcher; } });
+Object.defineProperty(exports, "PendingFollowUpManager", { enumerable: true, get: function () { return strictFollowUp_1.PendingFollowUpManager; } });
+var agentInstruction_1 = require("./agentInstruction");
+Object.defineProperty(exports, "evaluateAgentInstructions", { enumerable: true, get: function () { return agentInstruction_1.evaluateAgentInstructions; } });
+Object.defineProperty(exports, "defineInstruction", { enumerable: true, get: function () { return agentInstruction_1.defineInstruction; } });
+var buildInstructionsToLLMSubflow_1 = require("./buildInstructionsToLLMSubflow");
+Object.defineProperty(exports, "buildInstructionsToLLMSubflow", { enumerable: true, get: function () { return buildInstructionsToLLMSubflow_1.buildInstructionsToLLMSubflow; } });
+//# sourceMappingURL=index.js.map

package/dist/lib/instructions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/instructions/index.ts"],"names":[],"mappings":";;;AAAA,iCAA4C;AAAnC,kGAAA,SAAS,OAAA;AAAE,+FAAA,MAAM,OAAA;AAW1B,yCAAwG;AAA/F,iHAAA,oBAAoB,OAAA;AAAE,qHAAA,wBAAwB,OAAA;AAAE,sHAAA,yBAAyB,OAAA;AAGlF,uCAAgD;AAAvC,8GAAA,kBAAkB,OAAA;AAG3B,mCAA+C;AAAtC,6GAAA,mBAAmB,OAAA;AAG5B,qCAAgD;AAAvC,8GAAA,mBAAmB,OAAA;AAG5B,6DAA4D;AAAnD,0HAAA,mBAAmB,OAAA;AAG5B,mDAAmF;AAA1E,yHAAA,uBAAuB,OAAA;AAAE,wHAAA,sBAAsB,OAAA;AAGxD,uDAAkF;AAAzE,6HAAA,yBAAyB,OAAA;AAAE,qHAAA,iBAAiB,OAAA;AAGrD,iFAAgF;AAAvE,8IAAA,6BAA6B,OAAA"}