aiden-runtime 4.1.5 → 4.6.0

package/dist/core/v4/daemon/dispatcher/dispatcher.js

@@ -0,0 +1,389 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/daemon/dispatcher/dispatcher.ts — v4.5 Phase 5a.
+ *
+ * The bus consumer. Bridges the durable trigger queue
+ * (`triggerBus`) to the agent loop (`DaemonAgentRunner`).
+ *
+ * Loop body (workerCount-bounded, default 1 per Q-P5-1):
+ *
+ *   1. `triggerBus.claim({ownerId, leaseMs})` — atomic claim.
+ *   2. Read trigger spec row (`triggers` table) for fire_rate_limit /
+ *      prompt_template / deliver_only. Missing row → defaults
+ *      (no template, not deliver-only, no fire-rate cap).
+ *   3. Build sessionId via `buildTriggerSessionId`.
+ *   4. Render prompt template (if any) with payload vars. Missing
+ *      vars + non-empty template → markFailed with
+ *      `trigger_misconfigured` classification hint.
+ *   5. Start lease-renew timer (default 60s cadence, extends by
+ *      `leaseMs`). Runs for the lifetime of the invocation.
+ *   6. Invoke runner. Catch any throw.
+ *   7. On clean return → `markDone(eventId, claimToken, runId)`.
+ *      On throw or error finish-reason → `markFailed` which auto-
+ *      transitions to `dead_letter` after `maxAttempts`.
+ *   8. Renew timer cleared.
+ *
+ * Concurrency: a semaphore (in-flight count vs workerCount)
+ * guards the claim loop. Each claim spawns an async worker that
+ * decrements the semaphore on exit. The poll interval is short
+ * (250ms) when no event was claimed; it ratchets up via the
+ * adaptive backoff inside `_pollOnce` when the bus is empty.
+ *
+ * Shutdown: `stop(timeoutMs)` flips an `_stopping` flag, then
+ * awaits the in-flight worker promises (race against
+ * `timeoutMs`). Workers that exceed the deadline are NOT killed
+ * (the runner contract is cooperative-stop; runs eventually
+ * land in `markFailed` via the claim-lease-expired path on the
+ * next instance).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDispatcher = createDispatcher;
+exports._dispatcherOwnerId = _dispatcherOwnerId;
+const node_crypto_1 = require("node:crypto");
+const sessionId_1 = require("./sessionId");
+const promptTemplate_1 = require("./promptTemplate");
+const agentRunner_1 = require("./agentRunner");
+const realAgentRunner_1 = require("./realAgentRunner");
+// ── Defaults ───────────────────────────────────────────────────────────────
+const DEFAULT_WORKER_COUNT = 1;
+const DEFAULT_POLL_IDLE_MS = 250;
+const DEFAULT_POLL_BUSY_MS = 0; // immediate re-poll while events drain
+const DEFAULT_LEASE_MS = 5 * 60000;
+const DEFAULT_RENEW_MS = 60000;
+const DEFAULT_MAX_ATTEMPTS = 3;
+const DEFAULT_STOP_TIMEOUT_MS = 30000;
+// ── Implementation ─────────────────────────────────────────────────────────
+function createDispatcher(opts) {
+    const workerCount = opts.workerCount ?? DEFAULT_WORKER_COUNT;
+    const leaseMs = opts.leaseMs ?? DEFAULT_LEASE_MS;
+    const renewMs = opts.renewMs ?? DEFAULT_RENEW_MS;
+    const maxAttempts = opts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+    const pollIdleMs = opts.pollIdleMs ?? DEFAULT_POLL_IDLE_MS;
+    const log = opts.log ?? (() => { });
+    let runner = null;
+    // v4.5 Phase 7c — `runnerKind` lets diagnostics + tests distinguish
+    // the placeholder-runner phase from the real-agent-runner phase.
+    // The factory-bound initial runner is tagged 'placeholder' by
+    // default; `installRunner` flips to 'real'.
+    let _runnerKind = 'none';
+    let _started = false;
+    let _stopping = false;
+    let _pollTimer = null;
+    const _inflight = new Map();
+    const _workerPromises = new Set();
+    const _stats = {
+        claimed: 0,
+        succeeded: 0,
+        failed: 0,
+        deadLetter: 0,
+        deliverOnly: 0,
+        misconfigured: 0,
+    };
+    // ── Trigger spec lookup ─────────────────────────────────────────────────
+    function readTriggerSpec(sourceKey) {
+        try {
+            const row = opts.db
+                .prepare('SELECT * FROM triggers WHERE id = ?')
+                .get(sourceKey);
+            return row ?? null;
+        }
+        catch (e) {
+            log('warn', `[dispatcher] failed to read trigger spec ${sourceKey}: ${e instanceof Error ? e.message : String(e)}`);
+            return null;
+        }
+    }
+    // ── Build TriggerInvocationContext ──────────────────────────────────────
+    function buildContext(event, spec) {
+        return {
+            triggerId: event.sourceKey,
+            source: event.source,
+            sourceKey: event.sourceKey,
+            fireReason: typeof event.payload.fireReason === 'string'
+                ? event.payload.fireReason
+                : 'trigger_fired',
+            eventId: event.id,
+            attempt: event.attempts,
+            maxAttempts,
+            promptTemplate: spec?.prompt_template ?? null,
+        };
+    }
+    // ── Render initial message ──────────────────────────────────────────────
+    /**
+     * Returns the rendered message + missing-vars list. When no
+     * template is set, falls back to a structured JSON dump of the
+     * payload — the agent gets a readable initial prompt even
+     * without operator-supplied templates.
+     */
+    function renderInitialMessage(event, template) {
+        if (template && template.length > 0) {
+            const vars = (0, promptTemplate_1.flattenPayloadToVars)(event.payload);
+            // Inject a couple of dispatcher-known fields so templates can
+            // reference {{eventId}} / {{source}} / {{attempt}} / etc.
+            vars.eventId = event.id;
+            vars.source = event.source;
+            vars.sourceKey = event.sourceKey;
+            vars.attempt = event.attempts;
+            const { rendered, missing } = (0, promptTemplate_1.renderPromptTemplate)(template, vars);
+            return { message: rendered, missing };
+        }
+        // Fallback: structured payload header so the model knows the
+        // source + can reason over the JSON body. Keeps the initial
+        // message useful when the operator skipped the template.
+        return {
+            message: defaultInitialMessage(event),
+            missing: [],
+        };
+    }
+    function defaultInitialMessage(event) {
+        const header = `Trigger fired: ${event.source} (id=${event.sourceKey})`;
+        let body;
+        try {
+            body = JSON.stringify(event.payload, null, 2);
+        }
+        catch {
+            body = '<payload not serialisable>';
+        }
+        return `${header}\n\nPayload:\n\`\`\`json\n${body}\n\`\`\``;
+    }
+    // ── Lease renewal ───────────────────────────────────────────────────────
+    function startRenewTimer(eventId, claimToken) {
+        const t = setInterval(() => {
+            try {
+                const ok = opts.triggerBus.renewClaim(eventId, claimToken, leaseMs);
+                if (!ok) {
+                    log('warn', `[dispatcher] renew failed eventId=${eventId} — claim invalidated`);
+                    clearInterval(t);
+                }
+            }
+            catch (e) {
+                log('warn', `[dispatcher] renew threw eventId=${eventId}: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }, renewMs);
+        if (typeof t.unref === 'function')
+            t.unref();
+        return t;
+    }
+    // ── Process one claim ───────────────────────────────────────────────────
+    async function processClaim(event) {
+        const spec = readTriggerSpec(event.sourceKey);
+        const context = buildContext(event, spec);
+        const sessionId = (0, sessionId_1.buildTriggerSessionId)({
+            source: event.source,
+            sourceKey: event.sourceKey,
+            idempotencyKey: event.idempotencyKey,
+        });
+        // Record in-flight.
+        const inflightRow = {
+            eventId: event.id,
+            sessionId,
+            source: event.source,
+            startedAt: Date.now(),
+        };
+        _inflight.set(event.id, inflightRow);
+        // Start renew timer; clean up on every exit path.
+        const renewTimer = startRenewTimer(event.id, event.claimToken);
+        try {
+            // Render initial message + check missing vars.
+            const { message, missing } = renderInitialMessage(event, spec?.prompt_template ?? null);
+            if (missing.length > 0 && spec?.prompt_template) {
+                const reason = `trigger_misconfigured: template references undefined vars: ${missing.join(', ')}`;
+                log('warn', `[dispatcher] ${reason} (eventId=${event.id} trigger=${event.sourceKey})`);
+                // misconfigured = permanent failure; no cooldown needed since
+                // retry won't help, but we still call markFailed (which will
+                // dead-letter after maxAttempts).
+                opts.triggerBus.markFailed(event.id, event.claimToken, reason, { maxAttempts });
+                _stats.misconfigured += 1;
+                _stats.failed += 1;
+                // markFailed may transition to dead_letter when attempts >= maxAttempts.
+                if (event.attempts >= maxAttempts)
+                    _stats.deadLetter += 1;
+                return;
+            }
+            // Build the input + branch on deliverOnly.
+            const deliverOnly = spec?.deliver_only === 1;
+            const input = {
+                sessionId,
+                instanceId: opts.instanceId,
+                triggerEventId: event.id,
+                triggerContext: context,
+                initialMessage: message,
+                deliverOnly,
+            };
+            let result;
+            if (deliverOnly) {
+                result = (0, agentRunner_1.deliverOnlyStub)(input, opts.runStore);
+                _stats.deliverOnly += 1;
+            }
+            else {
+                if (!runner) {
+                    // Safety net — start() guarantees runner is set, but be
+                    // defensive in case of test misuse.
+                    throw new Error('dispatcher: runnerFactory has not been invoked');
+                }
+                // Discard return — we just need it to not be unused.
+                void agentRunner_1.buildInitialHistory;
+                result = await runner.invoke(input);
+            }
+            // Map finishReason to bus action.
+            if (result.finishReason === 'error') {
+                const errMsg = result.error ?? 'agent reported error finish';
+                opts.triggerBus.markFailed(event.id, event.claimToken, errMsg, {
+                    maxAttempts,
+                    cooldownMs: (0, realAgentRunner_1.computeRetryCooldownMs)(event.attempts),
+                });
+                _stats.failed += 1;
+                if (event.attempts >= maxAttempts)
+                    _stats.deadLetter += 1;
+                return;
+            }
+            // Success — markDone with the runId.
+            opts.triggerBus.markDone(event.id, event.claimToken, result.runId);
+            _stats.succeeded += 1;
+        }
+        catch (e) {
+            const msg = e instanceof Error ? (e.stack ?? e.message) : String(e);
+            log('error', `[dispatcher] worker threw eventId=${event.id}: ${msg}`);
+            try {
+                opts.triggerBus.markFailed(event.id, event.claimToken, msg.slice(0, 500), {
+                    maxAttempts,
+                    cooldownMs: (0, realAgentRunner_1.computeRetryCooldownMs)(event.attempts),
+                });
+            }
+            catch { /* bus may be in a weird state; swallow */ }
+            _stats.failed += 1;
+            if (event.attempts >= maxAttempts)
+                _stats.deadLetter += 1;
+        }
+        finally {
+            clearInterval(renewTimer);
+            _inflight.delete(event.id);
+        }
+    }
+    // ── Worker semaphore + claim loop ───────────────────────────────────────
+    async function _pollOnce() {
+        if (_stopping)
+            return null;
+        if (_inflight.size >= workerCount)
+            return null;
+        const event = opts.triggerBus.claim({ ownerId: opts.ownerId, leaseMs });
+        if (!event)
+            return null;
+        _stats.claimed += 1;
+        log('info', `[dispatcher] claimed eventId=${event.id} source=${event.source} attempt=${event.attempts}/${maxAttempts}`);
+        const p = processClaim(event).finally(() => {
+            _workerPromises.delete(p);
+        });
+        _workerPromises.add(p);
+        return event.id;
+    }
+    function _schedulePoll() {
+        if (_stopping)
+            return;
+        if (_pollTimer)
+            return;
+        _pollTimer = setTimeout(async () => {
+            _pollTimer = null;
+            try {
+                const claimedId = await _pollOnce();
+                // Adaptive: if we just claimed something, re-poll immediately
+                // (drain bus); otherwise wait `pollIdleMs`.
+                const next = claimedId !== null ? DEFAULT_POLL_BUSY_MS : pollIdleMs;
+                if (!_stopping) {
+                    _pollTimer = setTimeout(_schedulePollFromTimer, next);
+                    if (_pollTimer && typeof _pollTimer.unref === 'function')
+                        _pollTimer.unref();
+                }
+            }
+            catch (e) {
+                log('error', `[dispatcher] poll threw: ${e instanceof Error ? e.message : String(e)}`);
+                if (!_stopping) {
+                    _pollTimer = setTimeout(_schedulePollFromTimer, pollIdleMs);
+                    if (_pollTimer && typeof _pollTimer.unref === 'function')
+                        _pollTimer.unref();
+                }
+            }
+        }, pollIdleMs);
+        if (typeof _pollTimer.unref === 'function')
+            _pollTimer.unref();
+    }
+    function _schedulePollFromTimer() {
+        _pollTimer = null;
+        _schedulePoll();
+    }
+    return {
+        start() {
+            if (_started)
+                return;
+            _started = true;
+            runner = opts.runnerFactory();
+            // Initial runner from the factory is the placeholder unless the
+            // factory itself returned a real runner. The CLI's two-phase
+            // bootstrap (Phase 7c) starts with a placeholder factory and
+            // calls `installRunner` later with the real one.
+            _runnerKind = 'placeholder';
+            log('info', `[dispatcher] starting workerCount=${workerCount} leaseMs=${leaseMs} runner=placeholder`);
+            _schedulePoll();
+        },
+        installRunner(next) {
+            // Atomic swap — JS single-threaded execution means the read in
+            // _pumpOnce / processClaim can never see a half-installed runner.
+            runner = next;
+            _runnerKind = 'real';
+            log('info', `[dispatcher] runner swapped → real (next claim uses new runner)`);
+        },
+        runnerKind() {
+            return _runnerKind;
+        },
+        async stop(timeoutMs = DEFAULT_STOP_TIMEOUT_MS) {
+            _stopping = true;
+            if (_pollTimer) {
+                clearTimeout(_pollTimer);
+                _pollTimer = null;
+            }
+            // Race in-flight drain against the timeout.
+            const drain = Promise.allSettled([..._workerPromises]);
+            const deadline = new Promise((resolve) => {
+                const t = setTimeout(() => resolve(), timeoutMs);
+                if (typeof t.unref === 'function')
+                    t.unref();
+            });
+            await Promise.race([drain, deadline]);
+            log('info', `[dispatcher] stopped — inflight=${_inflight.size} processed=${_stats.claimed}`);
+        },
+        inflight() {
+            return [..._inflight.values()];
+        },
+        stats() {
+            return { ..._stats };
+        },
+        async _pumpOnce() {
+            if (!runner)
+                runner = opts.runnerFactory();
+            const event = opts.triggerBus.claim({ ownerId: opts.ownerId, leaseMs });
+            if (!event)
+                return null;
+            _stats.claimed += 1;
+            // Track the worker promise so stop() can wait on it.
+            const p = processClaim(event);
+            _workerPromises.add(p);
+            try {
+                await p;
+            }
+            finally {
+                _workerPromises.delete(p);
+            }
+            return event.id;
+        },
+    };
+}
+// Unique id helper (kept here so dispatchers in tests can use the
+// same util their producers do when fabricating event ids).
+function _dispatcherOwnerId(prefix = 'disp') {
+    return `${prefix}-${(0, node_crypto_1.randomUUID)()}`;
+}

package/dist/core/v4/daemon/dispatcher/fireRateLimiter.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/daemon/dispatcher/fireRateLimiter.ts — v4.5 Phase 5a.
+ *
+ * Per-trigger sliding-window fire-rate cap.
+ *
+ * Q-P5-5(c): unlimited by default. Each trigger spec carries an
+ * optional `fireRateLimit` (rows-per-window). When set, this
+ * module enforces a per-triggerId sliding window of size
+ * `windowMs` (default 1 hour). The Nth fire within the window is
+ * the LAST one allowed; the (N+1)th and beyond are blocked.
+ *
+ * Behaviour when blocked:
+ *   - `check()` returns `false` + populates `reason` field
+ *   - producer chooses what to do (typical: insert event + immediately
+ *     dead-letter so the operator has forensic visibility via
+ *     `/api/daemon/triggers/<id>/stats`)
+ *
+ * Anti-thrash motivation (from the prior-systems learning batch): a
+ * misconfigured webhook upstream can fire 60k times per minute. A
+ * busted file watcher on a temp directory can fire 1000 times per
+ * second. The producer-side cap stops the bus from inflating and
+ * keeps the operator's ability to query "what blew up" intact.
+ *
+ * Storage: in-memory `Map<triggerId, number[]>` of fire timestamps
+ * within the active window. Pruned lazily on each `check()` —
+ * old timestamps drop off the front when they fall outside `now -
+ * windowMs`. Bounded by max-fires-per-window (no unbounded growth
+ * even if the producer keeps hammering — once over the cap,
+ * incoming attempts are rejected immediately without recording).
+ *
+ * Idempotent reset via `__resetForTests()`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFireRateLimiter = createFireRateLimiter;
+exports.getFireRateLimiter = getFireRateLimiter;
+exports.__resetFireRateLimiterSingletonForTests = __resetFireRateLimiterSingletonForTests;
+const DEFAULT_WINDOW_MS = 60 * 60 * 1000; // 1 hour
+function createFireRateLimiter(opts = {}) {
+    const windowMs = opts.windowMs ?? DEFAULT_WINDOW_MS;
+    const windows = new Map();
+    function prune(triggerId, now) {
+        const cutoff = now - windowMs;
+        const list = windows.get(triggerId);
+        if (!list)
+            return [];
+        // Find the first timestamp >= cutoff and slice. Most-common case:
+        // few or zero entries to drop, so iterate from the front.
+        let i = 0;
+        while (i < list.length && list[i] < cutoff)
+            i++;
+        if (i > 0) {
+            const kept = list.slice(i);
+            if (kept.length === 0)
+                windows.delete(triggerId);
+            else
+                windows.set(triggerId, kept);
+            return kept;
+        }
+        return list;
+    }
+    return {
+        check(triggerId, limit, now = Date.now()) {
+            // Unlimited path — bypass entirely. No window recording.
+            if (limit === null || limit === undefined || limit <= 0) {
+                return { allowed: true, windowCount: 0, limit };
+            }
+            const list = prune(triggerId, now);
+            if (list.length >= limit) {
+                return {
+                    allowed: false,
+                    windowCount: list.length,
+                    limit,
+                    reason: `fire-rate cap exceeded: ${list.length}/${limit} per ${Math.round(windowMs / 1000)}s window`,
+                };
+            }
+            // Allowed — record the fire.
+            const next = [...list, now];
+            windows.set(triggerId, next);
+            return { allowed: true, windowCount: next.length, limit };
+        },
+        peek(triggerId, now = Date.now()) {
+            return prune(triggerId, now).length;
+        },
+        reset(triggerId) {
+            windows.delete(triggerId);
+        },
+        __resetForTests() {
+            windows.clear();
+        },
+    };
+}
+// Process-wide singleton — most call sites (producer-side fire
+// gates) want a shared limiter. Tests instantiate their own.
+let _singleton = null;
+/** Return the process-wide limiter, creating it on first call. */
+function getFireRateLimiter() {
+    if (!_singleton)
+        _singleton = createFireRateLimiter();
+    return _singleton;
+}
+/** Test-only — reset the singleton. */
+function __resetFireRateLimiterSingletonForTests() {
+    if (_singleton)
+        _singleton.__resetForTests();
+    _singleton = null;
+}

package/dist/core/v4/daemon/dispatcher/index.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/daemon/dispatcher/index.ts — v4.5 Phase 5a barrel.
+ *
+ * Single import point for the trigger dispatcher subsystem.
+ * Callers should import from here (`../dispatcher`) rather than
+ * the individual module files so internal refactors stay
+ * encapsulated.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPerTurnBudgetWatcher = exports.consumePostTurn = exports.evaluatePreTurn = exports.utcDateKey = exports.createDailyBudgetTracker = exports.DEFAULT_DAEMON_APPROVAL_POLICY = exports.isDaemonApprovalPolicy = exports.decideForPolicy = exports.buildDaemonApprovalCallbacks = exports.resolveDaemonModel = exports.RETRY_DECISION = exports.computeRetryCooldownMs = exports.createRealAgentRunner = exports.makeRunner = exports.deliverOnlyStub = exports.buildInitialHistory = exports.__resetFireRateLimiterSingletonForTests = exports.getFireRateLimiter = exports.createFireRateLimiter = exports.flattenPayloadToVars = exports.renderPromptTemplate = exports.parseTriggerSessionId = exports.buildTriggerSessionId = exports._dispatcherOwnerId = exports.createDispatcher = void 0;
+var dispatcher_1 = require("./dispatcher");
+Object.defineProperty(exports, "createDispatcher", { enumerable: true, get: function () { return dispatcher_1.createDispatcher; } });
+Object.defineProperty(exports, "_dispatcherOwnerId", { enumerable: true, get: function () { return dispatcher_1._dispatcherOwnerId; } });
+var sessionId_1 = require("./sessionId");
+Object.defineProperty(exports, "buildTriggerSessionId", { enumerable: true, get: function () { return sessionId_1.buildTriggerSessionId; } });
+Object.defineProperty(exports, "parseTriggerSessionId", { enumerable: true, get: function () { return sessionId_1.parseTriggerSessionId; } });
+var promptTemplate_1 = require("./promptTemplate");
+Object.defineProperty(exports, "renderPromptTemplate", { enumerable: true, get: function () { return promptTemplate_1.renderPromptTemplate; } });
+Object.defineProperty(exports, "flattenPayloadToVars", { enumerable: true, get: function () { return promptTemplate_1.flattenPayloadToVars; } });
+var fireRateLimiter_1 = require("./fireRateLimiter");
+Object.defineProperty(exports, "createFireRateLimiter", { enumerable: true, get: function () { return fireRateLimiter_1.createFireRateLimiter; } });
+Object.defineProperty(exports, "getFireRateLimiter", { enumerable: true, get: function () { return fireRateLimiter_1.getFireRateLimiter; } });
+Object.defineProperty(exports, "__resetFireRateLimiterSingletonForTests", { enumerable: true, get: function () { return fireRateLimiter_1.__resetFireRateLimiterSingletonForTests; } });
+var agentRunner_1 = require("./agentRunner");
+Object.defineProperty(exports, "buildInitialHistory", { enumerable: true, get: function () { return agentRunner_1.buildInitialHistory; } });
+Object.defineProperty(exports, "deliverOnlyStub", { enumerable: true, get: function () { return agentRunner_1.deliverOnlyStub; } });
+Object.defineProperty(exports, "makeRunner", { enumerable: true, get: function () { return agentRunner_1.makeRunner; } });
+// v4.5 Phase 7 — real agent runner + dependencies.
+var realAgentRunner_1 = require("./realAgentRunner");
+Object.defineProperty(exports, "createRealAgentRunner", { enumerable: true, get: function () { return realAgentRunner_1.createRealAgentRunner; } });
+Object.defineProperty(exports, "computeRetryCooldownMs", { enumerable: true, get: function () { return realAgentRunner_1.computeRetryCooldownMs; } });
+Object.defineProperty(exports, "RETRY_DECISION", { enumerable: true, get: function () { return realAgentRunner_1.RETRY_DECISION; } });
+var resolveModel_1 = require("./resolveModel");
+Object.defineProperty(exports, "resolveDaemonModel", { enumerable: true, get: function () { return resolveModel_1.resolveDaemonModel; } });
+var daemonApproval_1 = require("./daemonApproval");
+Object.defineProperty(exports, "buildDaemonApprovalCallbacks", { enumerable: true, get: function () { return daemonApproval_1.buildDaemonApprovalCallbacks; } });
+Object.defineProperty(exports, "decideForPolicy", { enumerable: true, get: function () { return daemonApproval_1.decideForPolicy; } });
+Object.defineProperty(exports, "isDaemonApprovalPolicy", { enumerable: true, get: function () { return daemonApproval_1.isDaemonApprovalPolicy; } });
+Object.defineProperty(exports, "DEFAULT_DAEMON_APPROVAL_POLICY", { enumerable: true, get: function () { return daemonApproval_1.DEFAULT_DAEMON_APPROVAL_POLICY; } });
+var dailyBudgetTracker_1 = require("./dailyBudgetTracker");
+Object.defineProperty(exports, "createDailyBudgetTracker", { enumerable: true, get: function () { return dailyBudgetTracker_1.createDailyBudgetTracker; } });
+Object.defineProperty(exports, "utcDateKey", { enumerable: true, get: function () { return dailyBudgetTracker_1.utcDateKey; } });
+var budgetGate_1 = require("./budgetGate");
+Object.defineProperty(exports, "evaluatePreTurn", { enumerable: true, get: function () { return budgetGate_1.evaluatePreTurn; } });
+Object.defineProperty(exports, "consumePostTurn", { enumerable: true, get: function () { return budgetGate_1.consumePostTurn; } });
+Object.defineProperty(exports, "createPerTurnBudgetWatcher", { enumerable: true, get: function () { return budgetGate_1.createPerTurnBudgetWatcher; } });

package/dist/core/v4/daemon/dispatcher/promptTemplate.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/daemon/dispatcher/promptTemplate.ts — v4.5 Phase 5a.
+ *
+ * Minimal `{{var}}` interpolation for trigger prompt templates.
+ *
+ * Per Q-P5-2(a): NO conditionals, NO loops, NO escapes. A trigger's
+ * spec.promptTemplate is a one-line-or-multi-line string with
+ * `{{path}}`, `{{event}}`, `{{from}}`, `{{subject}}` placeholders.
+ * The dispatcher renders it with payload-derived variables when
+ * deliverOnly is true OR the agent's initial message comes from a
+ * template.
+ *
+ * Missing-variable behaviour: the placeholder is LEFT IN PLACE and
+ * the name is collected in `missing`. The dispatcher decides what
+ * to do — currently it classifies a non-empty `missing` array as
+ * `trigger_misconfigured` when the template was non-empty.
+ *
+ * Whitespace inside braces tolerated: `{{ path }}` ≡ `{{path}}`.
+ * Unknown shapes (nested braces, `{{ }}` empty name) fail soft:
+ * left in place, not collected.
+ *
+ * Pure module — no I/O, no side effects, fully synchronous.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPromptTemplate = renderPromptTemplate;
+exports.flattenPayloadToVars = flattenPayloadToVars;
+const PLACEHOLDER = /\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g;
+/**
+ * Render a template with `{{var}}` placeholders.
+ *
+ * - Variables are looked up by exact name (after trimming whitespace).
+ * - Numeric / boolean values are stringified via `String(v)`.
+ * - `null` / `undefined` are treated as missing → placeholder left
+ *   in the output AND the variable name pushed onto `missing`.
+ * - Empty / whitespace-only template → returns `{ rendered: '', missing: [] }`.
+ *
+ * @param template Raw template string (may be empty).
+ * @param vars Variable map. Excess keys are ignored.
+ */
+function renderPromptTemplate(template, vars) {
+    if (typeof template !== 'string' || template.length === 0) {
+        return { rendered: '', missing: [] };
+    }
+    const missingSet = new Set();
+    const rendered = template.replace(PLACEHOLDER, (match, name) => {
+        const v = vars[name];
+        if (v === undefined || v === null) {
+            missingSet.add(name);
+            return match; // leave placeholder in place
+        }
+        return String(v);
+    });
+    return { rendered, missing: [...missingSet] };
+}
+/**
+ * Convenience helper for the common case where the dispatcher
+ * already has a TriggerEventRow payload + a few fixed fields
+ * and wants to render the template for that event. Caller can
+ * also call `renderPromptTemplate` directly with any var map.
+ *
+ * Variable shape varies by source — this helper just flattens
+ * the payload into top-level keys (e.g. `payload.from` →
+ * `{{from}}`). String/number/boolean values pass through;
+ * objects/arrays are JSON-stringified so they're at least
+ * substitutable (though usually undesirable in a user-facing
+ * prompt — Phase 5b cron may extend this with `{{json:foo}}`
+ * if needed).
+ */
+function flattenPayloadToVars(payload) {
+    const out = {};
+    for (const [k, v] of Object.entries(payload)) {
+        if (v === null || v === undefined) {
+            out[k] = null;
+        }
+        else if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') {
+            out[k] = v;
+        }
+        else {
+            try {
+                out[k] = JSON.stringify(v);
+            }
+            catch {
+                out[k] = String(v);
+            }
+        }
+    }
+    return out;
+}