aiden-runtime 4.1.5 → 4.6.0

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

@@ -0,0 +1,356 @@
+"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/realAgentRunner.ts — v4.5 Phase 7.
+ *
+ * Replaces the Phase 5a placeholder runner with a real
+ * `AidenAgent.runConversation` invocation.
+ *
+ * Why this is a *factory* + *injectable agent builder* rather than
+ * a direct `new AidenAgent(...)` call: the daemon module sits
+ * BELOW the CLI in the import graph — pulling provider /
+ * toolExecutor / plannerGuard / honesty / skillTeacher / ...
+ * construction into `core/v4/daemon` would invert the dependency
+ * direction. Instead, the CLI (which already owns agent
+ * construction for the REPL) injects an `AgentBuilder` function
+ * the runner calls per turn. Tests pass stubs.
+ *
+ * Bootstrap wiring (in `bootstrap.ts`):
+ *
+ *   - When AIDEN_DAEMON=1 AND an `agentBuilder` is provided →
+ *     `createRealAgentRunner({ ..., agentBuilder })` is the
+ *     dispatcher's runner factory.
+ *   - When no builder is provided → falls back to the Phase 5a
+ *     placeholder (still useful for rails-only integration tests
+ *     and for environments where the user has no provider
+ *     configured yet).
+ *
+ * Lifecycle per claim:
+ *
+ *   1. evaluatePreTurn — global daily budget check; reject with
+ *      `trigger_quota` tag when exhausted.
+ *   2. resolveDaemonModel — trigger spec → env → persisted chain.
+ *   3. buildDaemonApprovalCallbacks — non-interactive auto-decide
+ *      per Q-P7-1a policy.
+ *   4. createPerTurnBudgetWatcher — per-trigger soft cap; AbortSignal
+ *      threads into the agent invocation.
+ *   5. runStore.create() → runId; emit `dispatcher:invoked` with
+ *      sessionId, model, modelSource, policy, dailySnapshot.
+ *   6. Build initial history via buildInitialHistory(input).
+ *   7. agentBuilder({...}) → AidenAgent (caller-injected).
+ *   8. agent.runConversation(history) — major events emitted via
+ *      onToolCall + onBudgetWarning hooks → run_events.
+ *   9. Post-turn: consumePostTurn updates daily tracker; emit
+ *      `dispatcher:completed` with finishReason + totalTokens +
+ *      classification + retry decision.
+ *  10. Map AidenAgentResult → DaemonAgentResult.
+ *
+ * Failure handling: any throw or `finishReason: 'error'` is
+ * surfaced via DaemonAgentResult — the dispatcher (caller) maps
+ * to triggerBus.markFailed / deadLetter per the retry matrix.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RETRY_DECISION = void 0;
+exports.createRealAgentRunner = createRealAgentRunner;
+exports.computeRetryCooldownMs = computeRetryCooldownMs;
+const agentRunner_1 = require("./agentRunner");
+const resolveModel_1 = require("./resolveModel");
+const daemonApproval_1 = require("./daemonApproval");
+const dailyBudgetTracker_1 = require("./dailyBudgetTracker");
+const budgetGate_1 = require("./budgetGate");
+// ── Implementation ─────────────────────────────────────────────────────────
+const ENV_DAEMON_MODEL = 'AIDEN_DAEMON_MODEL';
+const ENV_DAILY_BUDGET = 'AIDEN_DAEMON_DAILY_BUDGET';
+function createRealAgentRunner(opts) {
+    const log = opts.log ?? (() => { });
+    const now = opts.now ?? Date.now;
+    const tracker = (0, dailyBudgetTracker_1.createDailyBudgetTracker)({
+        db: opts.db,
+        budget: opts.dailyBudget ?? readDailyBudgetFromEnv(),
+    });
+    return {
+        async invoke(input) {
+            const dailyBudget = opts.dailyBudget ?? readDailyBudgetFromEnv();
+            // ── 1: pre-turn budget gate ────────────────────────────────────────
+            const verdict = (0, budgetGate_1.evaluatePreTurn)({ tracker, dailyBudget, now: now() });
+            if (!verdict.allowed) {
+                // Reject without invoking the agent. Surface as trigger_quota.
+                const runId = opts.runStore.create({
+                    sessionId: input.sessionId,
+                    instanceId: input.instanceId,
+                    triggerEventId: input.triggerEventId,
+                    status: 'running',
+                });
+                opts.runStore.emitEvent(runId, 'dispatcher:rejected', {
+                    reason: verdict.reason ?? 'trigger_quota',
+                    dailySnapshot: verdict.daily,
+                });
+                opts.runStore.setStatus(runId, 'failed', { finishReason: 'budget_exhausted' });
+                log('warn', `[real-runner] rejected eventId=${input.triggerEventId}: ${verdict.reason}`);
+                return {
+                    runId,
+                    finishReason: 'error',
+                    error: verdict.reason ?? 'trigger_quota: daily budget exhausted',
+                };
+            }
+            // ── 2: resolve model from chain ───────────────────────────────────
+            const triggerSpec = readTriggerSpec(opts.db, input.triggerContext.triggerId);
+            const resolved = (0, resolveModel_1.resolveDaemonModel)({
+                triggerSpec: {
+                    provider: triggerSpec?.provider ?? null,
+                    model: triggerSpec?.model ?? null,
+                },
+                envOverride: process.env[ENV_DAEMON_MODEL],
+                persistedDefault: opts.persistedDefault ?? { provider: '', model: '' },
+            });
+            // ── 3: approval callbacks ─────────────────────────────────────────
+            const approvalPolicy = triggerSpec?.daemonApproval && (0, daemonApproval_1.isDaemonApprovalPolicy)(triggerSpec.daemonApproval)
+                ? triggerSpec.daemonApproval
+                : daemonApproval_1.DEFAULT_DAEMON_APPROVAL_POLICY;
+            // ── 4: per-turn budget watcher ────────────────────────────────────
+            const perTurnWatcher = (0, budgetGate_1.createPerTurnBudgetWatcher)({
+                maxTokensPerFire: triggerSpec?.maxTokensPerFire ?? null,
+            });
+            // ── 5: run row + dispatcher:invoked event ─────────────────────────
+            const runId = opts.runStore.create({
+                sessionId: input.sessionId,
+                instanceId: input.instanceId,
+                triggerEventId: input.triggerEventId,
+                status: 'running',
+            });
+            opts.runStore.emitEvent(runId, 'dispatcher:invoked', {
+                source: input.triggerContext.source,
+                triggerId: input.triggerContext.triggerId,
+                eventId: input.triggerEventId,
+                sessionId: input.sessionId,
+                templated: input.triggerContext.promptTemplate !== null,
+                messageLen: input.initialMessage.length,
+                attempt: input.triggerContext.attempt,
+                maxAttempts: input.triggerContext.maxAttempts,
+                model: resolved.model,
+                provider: resolved.provider,
+                modelSource: resolved.source,
+                approvalPolicy,
+                dailySnapshot: verdict.daily,
+                maxTokensPerFire: triggerSpec?.maxTokensPerFire ?? null,
+            });
+            const approvalCallbacks = (0, daemonApproval_1.buildDaemonApprovalCallbacks)({
+                policy: approvalPolicy,
+                runStore: opts.runStore,
+                runId,
+                log: (lvl, msg) => log(lvl, msg),
+            });
+            // ── 6: initial history ────────────────────────────────────────────
+            const history = (0, agentRunner_1.buildInitialHistory)(input);
+            // ── 7: build agent via injected factory ───────────────────────────
+            let agent;
+            const startedAt = now();
+            try {
+                agent = await opts.agentBuilder({
+                    sessionId: input.sessionId,
+                    resolvedModel: resolved,
+                    approvalPolicy,
+                    approvalCallbacks,
+                    hooks: {
+                        onToolCall: (call, phase, result) => emitToolEvent(opts.runStore, runId, call, phase, result, startedAt, now),
+                        onBudgetWarning: (level, turn, max) => {
+                            opts.runStore.emitEvent(runId, 'budget_warning', { level, turn, max });
+                        },
+                    },
+                    abortSignal: perTurnWatcher.signal,
+                });
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                log('error', `[real-runner] agentBuilder threw eventId=${input.triggerEventId}: ${msg}`);
+                opts.runStore.emitEvent(runId, 'dispatcher:builder_failed', { error: msg });
+                opts.runStore.setStatus(runId, 'failed', { finishReason: 'error' });
+                return { runId, finishReason: 'error', error: msg };
+            }
+            // ── 8: invoke runConversation ─────────────────────────────────────
+            let result = null;
+            let invocationError = null;
+            try {
+                result = await agent.runConversation(history, {
+                // The agent honours its own abort signal via per-tool aborts;
+                // tools that respect AbortSignal (shell_exec, fetch_*) will
+                // bail when perTurnWatcher trips.
+                //
+                // Note: runConversation doesn't currently take an abort
+                // signal in its options — the budget watcher is best-effort
+                // observability via tally(). Future enhancement: thread the
+                // signal into the loop body via options.
+                });
+                // Stamp the actual token usage onto the watcher for the
+                // post-turn snapshot below.
+                const tokens = extractTokens(result);
+                if (tokens > 0)
+                    perTurnWatcher.tally(tokens);
+            }
+            catch (e) {
+                invocationError = e instanceof Error ? (e.stack ?? e.message) : String(e);
+                log('error', `[real-runner] runConversation threw eventId=${input.triggerEventId}: ${invocationError.slice(0, 500)}`);
+            }
+            // ── 9: post-turn budget consume + dispatcher:completed ─────────────
+            const finalSnapshot = (0, budgetGate_1.consumePostTurn)({
+                tracker,
+                actualTokens: perTurnWatcher.used(),
+                dailyBudget,
+                now: now(),
+            });
+            const finishReason = pickFinishReason(result, invocationError, perTurnWatcher.hit());
+            opts.runStore.emitEvent(runId, 'dispatcher:completed', {
+                finishReason,
+                totalTokens: perTurnWatcher.used(),
+                durationMs: now() - startedAt,
+                dailySnapshot: finalSnapshot,
+                perTurnBudgetHit: perTurnWatcher.hit(),
+                perTurnReason: perTurnWatcher.reason(),
+                invocationError: invocationError ? invocationError.slice(0, 200) : null,
+            });
+            // ── 10: map result → DaemonAgentResult ────────────────────────────
+            const runStatus = finishReason === 'stop' ? 'completed' :
+                finishReason === 'budget_exhausted' ? 'failed' :
+                    finishReason === 'error' ? 'failed' :
+                        finishReason === 'tool_loop' ? 'failed' : 'completed';
+            opts.runStore.setStatus(runId, runStatus, { finishReason });
+            return {
+                runId,
+                finishReason,
+                totalTokens: perTurnWatcher.used() > 0 ? perTurnWatcher.used() : undefined,
+                error: invocationError ?? (perTurnWatcher.hit() ? perTurnWatcher.reason() ?? undefined : undefined),
+            };
+        },
+    };
+}
+// ── Helpers ────────────────────────────────────────────────────────────────
+/** Read the trigger spec row + extract Phase 7 spec fields. */
+function readTriggerSpec(db, triggerId) {
+    try {
+        const row = db.prepare(`SELECT spec_json FROM triggers WHERE id = ?`).get(triggerId);
+        if (!row)
+            return null;
+        const parsed = JSON.parse(row.spec_json);
+        return {
+            provider: typeof parsed.provider === 'string' ? parsed.provider : undefined,
+            model: typeof parsed.model === 'string' ? parsed.model : undefined,
+            daemonApproval: typeof parsed.daemonApproval === 'string' ? parsed.daemonApproval : undefined,
+            maxTokensPerFire: typeof parsed.maxTokensPerFire === 'number' ? parsed.maxTokensPerFire : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Read AIDEN_DAEMON_DAILY_BUDGET, parse as positive integer; null otherwise. */
+function readDailyBudgetFromEnv() {
+    const raw = process.env[ENV_DAILY_BUDGET];
+    if (!raw)
+        return null;
+    const n = Number.parseInt(raw, 10);
+    return Number.isFinite(n) && n > 0 ? n : null;
+}
+/** Major-events run_event emitter for tool calls. Truncated payload. */
+function emitToolEvent(runStore, runId, call, phase, result, startedAt, now) {
+    try {
+        if (phase === 'before') {
+            const argsSummary = safeShortJson(call.arguments, 200);
+            runStore.emitEvent(runId, 'tool_call_started', {
+                toolName: call.name,
+                args: argsSummary,
+                ts: now(),
+            });
+            return;
+        }
+        runStore.emitEvent(runId, 'tool_call_completed', {
+            toolName: call.name,
+            error: result?.error ?? null,
+            hasResult: result?.result !== undefined && result?.result !== null,
+            durationMs: now() - startedAt,
+        });
+    }
+    catch { /* never let observability crash the agent loop */ }
+}
+function safeShortJson(value, maxBytes) {
+    try {
+        const s = JSON.stringify(value);
+        return s.length > maxBytes ? s.slice(0, maxBytes) + '…' : s;
+    }
+    catch {
+        return String(value).slice(0, maxBytes);
+    }
+}
+/**
+ * Pull the total-tokens count off an AidenAgentResult. The agent
+ * exposes per-turn token usage via its result's `usage` field
+ * (mirrors provider conventions). Falls back to 0 when missing.
+ */
+function extractTokens(result) {
+    if (!result)
+        return 0;
+    const r = result;
+    return r.usage?.totalTokens ?? r.usage?.total ?? 0;
+}
+/**
+ * Map the agent's finishReason + invocation outcome → the
+ * DaemonAgentResult finishReason vocab the dispatcher expects.
+ */
+function pickFinishReason(result, invocationError, perTurnHit) {
+    if (invocationError)
+        return 'error';
+    if (perTurnHit)
+        return 'budget_exhausted';
+    if (!result)
+        return 'error';
+    const fr = result.finishReason;
+    if (fr === 'stop')
+        return 'stop';
+    if (fr === 'tool_loop')
+        return 'tool_loop';
+    if (fr === 'budget_exhausted')
+        return 'budget_exhausted';
+    if (fr === 'error')
+        return 'error';
+    // Default conservative — the dispatcher will markDone unless we
+    // say error; treat unknown finishes as success for forward-compat.
+    return 'stop';
+}
+exports.RETRY_DECISION = Object.freeze({
+    // Transient — retry with backoff
+    timeout: 'retry',
+    network: 'retry',
+    rate_limit: 'retry',
+    dependency_missing: 'retry',
+    hallucination: 'retry',
+    stale_ref: 'retry',
+    // Permanent — dead-letter immediately
+    auth: 'dead_letter',
+    permission: 'dead_letter',
+    sandbox_violation: 'dead_letter',
+    manual_blocker: 'dead_letter',
+    trigger_misconfigured: 'dead_letter',
+    trigger_quota: 'dead_letter',
+    trigger_dead_lettered: 'dead_letter',
+    invalid_input: 'dead_letter',
+    not_found: 'dead_letter',
+    other: 'dead_letter',
+});
+/**
+ * Compute the cooldown to wait before re-claiming a transient
+ * failure. Formula: `min(2^attempts * 1000, 60000)` ms.
+ * Exposed as a pure function so tests can assert the schedule:
+ *
+ *   attempts=1 → 2_000 ms
+ *   attempts=2 → 4_000 ms
+ *   attempts=3 → 8_000 ms
+ *   attempts=6 → 60_000 ms (capped)
+ */
+function computeRetryCooldownMs(attempts) {
+    const expo = Math.pow(2, Math.max(1, attempts)) * 1000;
+    return Math.min(expo, 60000);
+}

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

@@ -0,0 +1,93 @@
+"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/resolveModel.ts — v4.5 Phase 7.
+ *
+ * Per-trigger model selection chain (Q-P7-2a):
+ *
+ *   1. Trigger spec — `triggers.spec_json.provider/model` if either
+ *      is non-empty. Per-trigger configuration is the whole point
+ *      of trigger registration.
+ *   2. Environment override — `AIDEN_DAEMON_MODEL` env var encoded
+ *      as `<provider>/<model>` (e.g. "ollama/llama3.2:latest").
+ *      For operators who want one model across every trigger.
+ *   3. Persisted user default — last interactive-REPL choice loaded
+ *      via the caller-provided `persistedDefault` argument.
+ *
+ * The `source` field on the result is captured in the
+ * `dispatcher:invoked` run_event so operators can audit which leg
+ * of the chain won for a given turn.
+ *
+ * Pure module — no I/O, no fs reads. Caller is responsible for
+ * loading the persisted default (a separate concern from the
+ * chain logic).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDaemonModel = resolveDaemonModel;
+/**
+ * Resolve the (provider, model) pair to use for a daemon-fired
+ * agent turn. Deterministic per input.
+ *
+ * Edge cases:
+ *   - Both spec fields set → trigger wins (source='trigger').
+ *   - Only spec.provider set → trigger.provider + env/persisted.model
+ *     (still source='trigger' because at least one piece came from
+ *     the trigger).
+ *   - Only spec.model set → ditto.
+ *   - Neither spec field set → fall through to env / persisted.
+ *   - Env value present but malformed (no slash) → ignored; falls
+ *     through to persisted.
+ */
+function resolveDaemonModel(input) {
+    const spec = input.triggerSpec ?? {};
+    const env = parseEnvOverride(input.envOverride);
+    const specProvider = nonEmpty(spec.provider);
+    const specModel = nonEmpty(spec.model);
+    // Trigger wins if it contributes anything.
+    if (specProvider || specModel) {
+        return {
+            provider: specProvider ?? env?.provider ?? input.persistedDefault.provider,
+            model: specModel ?? env?.model ?? input.persistedDefault.model,
+            source: 'trigger',
+        };
+    }
+    // Env wins next.
+    if (env) {
+        return {
+            provider: env.provider,
+            model: env.model,
+            source: 'env',
+        };
+    }
+    // Fallback: persisted user default.
+    return {
+        provider: input.persistedDefault.provider,
+        model: input.persistedDefault.model,
+        source: 'persisted',
+    };
+}
+/** Parse the `AIDEN_DAEMON_MODEL` env value. Returns null on malformed input. */
+function parseEnvOverride(raw) {
+    if (typeof raw !== 'string' || raw.length === 0)
+        return null;
+    const slash = raw.indexOf('/');
+    // Require both halves non-empty: "<provider>/<model>".
+    if (slash <= 0 || slash >= raw.length - 1)
+        return null;
+    const provider = raw.slice(0, slash).trim();
+    const model = raw.slice(slash + 1).trim();
+    if (provider.length === 0 || model.length === 0)
+        return null;
+    return { provider, model };
+}
+function nonEmpty(v) {
+    if (typeof v !== 'string')
+        return undefined;
+    const t = v.trim();
+    return t.length > 0 ? t : undefined;
+}

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

@@ -0,0 +1,93 @@
+"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/sessionId.ts — v4.5 Phase 5a.
+ *
+ * Per-trigger sessionId derivation. Stable across retries — the
+ * same trigger event (same idempotencyKey) always produces the
+ * same sessionId, so:
+ *
+ *   - v4.4 docker session cache reuses one container per trigger
+ *     across retry attempts (cold-start cost amortised).
+ *   - v4.3 browser observer keeps page state observable for the
+ *     same trigger across re-attempts.
+ *   - v4.2 TurnState tracks repeated tool calls within a
+ *     single retry session (still fresh per turn — TurnState
+ *     lives per `runConversation`, not per sessionId).
+ *
+ * Format: `trigger:<source>:<sourceKey>:<idemHash>` where
+ *   - source: TriggerSource literal ('file' / 'webhook' / 'email'
+ *     / 'schedule' / 'manual')
+ *   - sourceKey: the trigger spec id (FK to triggers.id)
+ *   - idemHash: base64url(sha256(idempotencyKey)).slice(0,12)
+ *
+ * 12-char b64url prefix gives ~72 bits — far more than enough to
+ * keep distinct triggers separate without bloating the sessionId
+ * the docker cache / runStore have to carry around.
+ *
+ * `idempotencyKey === null` falls back to the literal `no-idem`
+ * sentinel — keeps the sessionId stable for sources that don't
+ * dedup (rare; mostly schedule).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTriggerSessionId = buildTriggerSessionId;
+exports.parseTriggerSessionId = parseTriggerSessionId;
+const node_crypto_1 = require("node:crypto");
+const NO_IDEM_SENTINEL = 'no-idem';
+/**
+ * Build a stable per-trigger sessionId.
+ *
+ * Deterministic: same input → same output. Tested for stability
+ * across retries (the trigger bus reclaims its existing event row;
+ * the dispatcher hands the same triple to this function on every
+ * attempt → same sessionId → same docker container / browser tab
+ * reused).
+ */
+function buildTriggerSessionId(input) {
+    const idem = input.idempotencyKey ?? NO_IDEM_SENTINEL;
+    const hash = sha256B64url(idem).slice(0, 12);
+    return `trigger:${input.source}:${input.sourceKey}:${hash}`;
+}
+/**
+ * Inverse-ish parser. Returns the structural pieces of a sessionId
+ * built by `buildTriggerSessionId`. Returns `null` for sessionIds
+ * not built by this helper (interactive REPL sessions, plain
+ * UUIDs, etc.).
+ *
+ * Used by recoveryReport to detect daemon-triggered runs and
+ * surface the `triggerContext` pill.
+ */
+function parseTriggerSessionId(sessionId) {
+    if (!sessionId.startsWith('trigger:'))
+        return null;
+    const parts = sessionId.split(':');
+    // ['trigger', source, sourceKey, idemHash]
+    if (parts.length !== 4)
+        return null;
+    const [, source, sourceKey, idemHash] = parts;
+    if (!isTriggerSource(source))
+        return null;
+    if (!sourceKey || sourceKey.length === 0)
+        return null;
+    if (!idemHash || idemHash.length === 0)
+        return null;
+    return { source, sourceKey, idemHash };
+}
+/** Type-guard for TriggerSource literals. */
+function isTriggerSource(s) {
+    return s === 'file' || s === 'webhook' || s === 'email'
+        || s === 'schedule' || s === 'manual';
+}
+function sha256B64url(input) {
+    return (0, node_crypto_1.createHash)('sha256')
+        .update(input)
+        .digest('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+$/, '');
+}