@evelinka-ai/core 0.1.3

package/dist/lib/observability/recorder.js

@@ -0,0 +1,1182 @@
+import { randomUUID } from "node:crypto";
+import { appendFileSync, closeSync, mkdirSync, openSync, readFileSync, readSync, statSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { publishSessionDelta } from "./event-bus.js";
+import { logger } from "./logger.js";
+import { savePayloadDocSerialized } from "./payload-store.js";
+const log = logger.child({ module: "recorder" });
+export function usagePatchFrom(id, at, usage, stepKey) {
+    if (!usage)
+        return null;
+    const { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens } = usage;
+    if (inputTokens === undefined &&
+        outputTokens === undefined &&
+        cacheReadTokens === undefined &&
+        cacheWriteTokens === undefined) {
+        return null;
+    }
+    return {
+        id,
+        at,
+        t: "usage",
+        input: inputTokens,
+        output: outputTokens,
+        cacheRead: cacheReadTokens,
+        cacheWrite: cacheWriteTokens,
+        ...(stepKey ? { stepKey } : {}),
+    };
+}
+export function stepKeyFrom(turnId, stepIndex) {
+    if (typeof turnId === "string" && typeof stepIndex === "number") {
+        return `${turnId}#${stepIndex}`;
+    }
+    return undefined;
+}
+export function storePath() {
+    return process.env.EVE_RECORDER_PATH ?? join(process.cwd(), ".workflow-data", "sessions.jsonl");
+}
+export function appendPatchStrict(patch, file = storePath()) {
+    mkdirSync(dirname(file), { recursive: true });
+    appendFileSync(file, `${JSON.stringify(patch)}\n`);
+    publishSessionDelta({ sessionId: patch.id, kind: patch.t, at: patch.at });
+}
+export function appendPatch(patch, file = storePath()) {
+    try {
+        appendPatchStrict(patch, file);
+    }
+    catch (err) {
+        log.error({ err, id: patch.id, t: patch.t }, "failed to append patch");
+    }
+}
+export function findSessionIdByInboundMarker(marker, file = storePath(), maxTailBytes = 2 * 1024 * 1024) {
+    const needle = `${JSON.stringify(marker).slice(1, -1)}\\"`;
+    const rawNeedle = `${marker}"`;
+    let raw;
+    try {
+        const size = statSync(file).size;
+        const start = Math.max(0, size - maxTailBytes);
+        const fd = openSync(file, "r");
+        try {
+            const buf = Buffer.alloc(size - start);
+            readSync(fd, buf, 0, buf.length, start);
+            raw = buf.toString("utf8");
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+    const lines = raw.split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const trimmed = lines[i].trim();
+        if (!trimmed || !(trimmed.includes(needle) || trimmed.includes(rawNeedle)))
+            continue;
+        try {
+            const p = JSON.parse(trimmed);
+            if (p?.t === "inbound" && typeof p.id === "string" && typeof p.text === "string") {
+                if (p.text.includes(rawNeedle))
+                    return p.id;
+            }
+        }
+        catch {
+        }
+    }
+    return null;
+}
+export function readPatches(file = storePath()) {
+    let raw;
+    try {
+        raw = readFileSync(file, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return [];
+        throw err;
+    }
+    const patches = [];
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const p = JSON.parse(trimmed);
+            if (p && typeof p.id === "string" && typeof p.t === "string")
+                patches.push(p);
+        }
+        catch {
+            log.warn("skipping malformed patch line");
+        }
+    }
+    return patches;
+}
+const KIND_TO_SOURCE = {
+    "channel:prospect": "prospect",
+    prospect: "prospect",
+    "channel:partners": "partners",
+    partners: "partners",
+    "channel:instagram": "instagram",
+    instagram: "instagram",
+    "channel:answers": "answers",
+    answers: "answers",
+    "channel:build-run": "build",
+    build: "build",
+    "channel:email": "email",
+    email: "email",
+    "channel:health-probe": "health",
+    health: "health",
+};
+export function deriveSource(token, channelKind) {
+    if (token?.startsWith("eve:eve:"))
+        token = token.slice("eve:".length);
+    const base = {
+        kind: "unknown",
+        repo: null,
+        prNumber: null,
+        sender: null,
+        url: null,
+        continuationToken: token ?? null,
+    };
+    const byKind = channelKind ? KIND_TO_SOURCE[channelKind] : undefined;
+    if (byKind)
+        return { ...base, kind: byKind };
+    if (!token)
+        return base;
+    if (token.startsWith("build-run:"))
+        return { ...base, kind: "build" };
+    if (token.startsWith("prospect:"))
+        return { ...base, kind: "prospect" };
+    if (token.startsWith("health-probe:"))
+        return { ...base, kind: "health" };
+    if (token.startsWith("eve:"))
+        return { ...base, kind: "web" };
+    if (token.startsWith("sentry:"))
+        return { ...base, kind: "sentry" };
+    if (token.startsWith("telegram:"))
+        return { ...base, kind: "telegram" };
+    if (token.startsWith("email:"))
+        return { ...base, kind: "email" };
+    if (token.startsWith("fixit:"))
+        return { ...base, kind: "fixit" };
+    const m = token.match(/^repo:[^:]+:(pull|issue):(\d+)/);
+    if (m) {
+        return { ...base, kind: "mention", prNumber: Number(m[2]) };
+    }
+    return base;
+}
+export function defaultTriggerFor(kind) {
+    switch (kind) {
+        case "pr":
+        case "mention":
+        case "review":
+        case "journey_refine":
+        case "sentry":
+        case "health":
+            return "webhook";
+        case "web":
+        case "telegram":
+        case "email":
+        case "fixit":
+            return "manual";
+        default:
+            return null;
+    }
+}
+export function parseGithubInbound(text) {
+    const field = (re) => text.match(re)?.[1]?.trim() ?? null;
+    const numStr = field(/pull_request_number:\s*(\d+)/) ?? field(/issue_number:\s*(\d+)/);
+    const close = text.indexOf("</github_context>");
+    let body = (close >= 0 ? text.slice(close + "</github_context>".length) : text).trim();
+    const modeMatch = body.match(/^mode:\s*(review|journey_refine)\s*(?:\n|$)/);
+    const mode = modeMatch ? modeMatch[1] : null;
+    let sentinelRepo = null;
+    let sentinelNumber = null;
+    let sentinelTitle = null;
+    if (modeMatch) {
+        body = body.slice(modeMatch[0].length);
+        let m;
+        while ((m = body.match(/^(headSha|Repo|Number|Title):[ \t]*([^\n]*)\n?/))) {
+            const val = m[2].trim();
+            if (m[1] === "Repo")
+                sentinelRepo = val || null;
+            else if (m[1] === "Number")
+                sentinelNumber = /^\d+$/.test(val) ? Number(val) : null;
+            else if (m[1] === "Title")
+                sentinelTitle = val || null;
+            body = body.slice(m[0].length);
+        }
+        body = body.trim();
+    }
+    return {
+        repo: field(/repository:\s*(\S+)/) ?? sentinelRepo,
+        number: numStr != null ? Number(numStr) : sentinelNumber,
+        sender: field(/sender:\s*(\S+)/),
+        url: field(/comment_url:\s*(\S+)/),
+        body,
+        mode,
+        title: sentinelTitle,
+        isPrOpened: /^Pull request \w+:\s*#\d+/.test(body),
+    };
+}
+export function parseSentryInbound(text) {
+    const field = (re) => text.match(re)?.[1]?.trim() ?? null;
+    return {
+        repo: field(/target_repo:\s*(\S+)/),
+        url: field(/issue_url:\s*(\S+)/),
+        shortId: field(/short_id:\s*(\S+)/),
+        environment: field(/environment:\s*(\S+)/),
+    };
+}
+function truncate(s, n = 80) {
+    const clean = s.replace(/\s+/g, " ").trim();
+    return clean.length > n ? `${clean.slice(0, n - 1)}…` : clean;
+}
+const SENSITIVE_KEY = /(token|secret|password|authorization|api[-_]?key|^key$|_key$|\bkey\b)/i;
+const MAX_STRING = 500;
+const MAX_DEPTH = 6;
+export const MAX_TOOL_STRING = 2000;
+export const FULL_PAYLOAD_DEPTH = 12;
+const MAX_ARRAY_ITEMS = 200;
+const MAX_OBJECT_KEYS = 200;
+const MAX_TOTAL_NODES = 5_000;
+export function redactValue(value, maxString = MAX_STRING, maxDepth = MAX_DEPTH, budget = {
+    nodes: MAX_TOTAL_NODES,
+    arrayItems: MAX_ARRAY_ITEMS,
+    objectKeys: MAX_OBJECT_KEYS,
+}) {
+    const masked = redactDeep(value, 0, maxString, maxDepth, budget);
+    try {
+        JSON.stringify(masked);
+    }
+    catch {
+        return "[unserializable]";
+    }
+    return masked;
+}
+const SECRET_STRING_PATTERNS = [
+    [
+        /([?&][^=&\s"']*(?:token|secret|password|signature|bypass|credential|apikey|api[-_]key|access[-_]key|sess(?:ion)?id)[^=&\s"']*=)[^&\s"']+/gi,
+        "$1[redacted]",
+    ],
+    [/\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]{8,}/g, "$1 [redacted]"],
+    [
+        /\b(sk-[A-Za-z0-9_-]{10,}|ghp_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16})\b/g,
+        "[redacted]",
+    ],
+    [/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,}\b/g, "[redacted]"],
+];
+function scrubSecretStrings(s) {
+    let out = s;
+    for (const [re, sub] of SECRET_STRING_PATTERNS)
+        out = out.replace(re, sub);
+    return out;
+}
+function redactDeep(value, depth, maxString, maxDepth, budget) {
+    if (budget.nodes <= 0)
+        return "[truncated]";
+    budget.nodes--;
+    if (typeof value === "string") {
+        const scrubbed = scrubSecretStrings(value);
+        return scrubbed.length > maxString ? `${scrubbed.slice(0, maxString - 1)}…` : scrubbed;
+    }
+    if (value === null || typeof value !== "object")
+        return value;
+    if (depth >= maxDepth)
+        return "[truncated]";
+    if (Array.isArray(value)) {
+        const capped = value
+            .slice(0, budget.arrayItems)
+            .map((v) => redactDeep(v, depth + 1, maxString, maxDepth, budget));
+        if (value.length > budget.arrayItems) {
+            capped.push(`[+${value.length - budget.arrayItems} items truncated]`);
+        }
+        return capped;
+    }
+    const out = {};
+    const rec = value;
+    let kept = 0;
+    let truncated = false;
+    for (const k in rec) {
+        if (!Object.hasOwn(rec, k))
+            continue;
+        if (kept >= budget.objectKeys || budget.nodes <= 0) {
+            truncated = true;
+            break;
+        }
+        out[k] = SENSITIVE_KEY.test(k)
+            ? "[redacted]"
+            : redactDeep(rec[k], depth + 1, maxString, maxDepth, budget);
+        kept++;
+    }
+    if (truncated)
+        out["[truncatedKeys]"] = true;
+    return out;
+}
+export function redactValueFull(value) {
+    return redactValue(value, Number.POSITIVE_INFINITY, FULL_PAYLOAD_DEPTH, {
+        nodes: Number.POSITIVE_INFINITY,
+        arrayItems: Number.POSITIVE_INFINITY,
+        objectKeys: Number.POSITIVE_INFINITY,
+    });
+}
+export function fullPayloadDocIdFor(result, summary) {
+    const full = redactValueFull(result);
+    let fullSerialized;
+    let summarySerialized;
+    try {
+        fullSerialized = JSON.stringify(full);
+        summarySerialized = JSON.stringify(summary);
+    }
+    catch {
+        return undefined;
+    }
+    if (fullSerialized === undefined || fullSerialized === summarySerialized)
+        return undefined;
+    return savePayloadDocSerialized(fullSerialized) ?? undefined;
+}
+function titleFor(source, inbound) {
+    if (source.kind === "pr" || source.kind === "review") {
+        const gh = parseGithubInbound(inbound);
+        const prTitle = gh.title ?? (gh.isPrOpened ? gh.body.replace(/^Pull request \w+:\s*#\d+\s*/, "").trim() : "");
+        const num = source.prNumber ?? gh.number;
+        const prefix = source.kind === "review" ? "Review PR" : "PR";
+        return prTitle ? `${prefix} #${num} · ${truncate(prTitle, 72)}` : `${prefix} #${num}`;
+    }
+    if (source.kind === "mention") {
+        const gh = parseGithubInbound(inbound);
+        const where = source.prNumber ? `#${source.prNumber} ` : "";
+        return gh.body ? `${where}@mention · ${truncate(gh.body, 64)}` : `${where}@mention`;
+    }
+    if (source.kind === "journey_refine") {
+        const num = source.prNumber ?? parseGithubInbound(inbound).number;
+        return num != null ? `Refine journeys · PR #${num}` : "Refine journeys";
+    }
+    if (source.kind === "sentry") {
+        const s = parseSentryInbound(inbound);
+        const env = s.environment ? ` · ${s.environment}` : "";
+        return s.shortId ? `Sentry · ${s.shortId}${env}` : "Sentry issue";
+    }
+    if (source.kind === "prospect") {
+        return inbound ? `Prospect · ${truncate(inbound, 72)}` : "Prospect run";
+    }
+    if (source.kind === "partners") {
+        return inbound ? `Partneři · ${truncate(inbound, 72)}` : "Partner scan";
+    }
+    if (source.kind === "instagram") {
+        return inbound ? `Instagram · ${truncate(inbound, 72)}` : "Instagram scan";
+    }
+    if (source.kind === "answers") {
+        return inbound ? `Odpovědi · ${truncate(inbound, 72)}` : "Answers run";
+    }
+    if (source.kind === "build") {
+        return inbound ? `Build · ${truncate(inbound, 72)}` : "Build preview";
+    }
+    if (source.kind === "email") {
+        return inbound ? `Email · ${truncate(inbound, 72)}` : "Email";
+    }
+    return inbound ? truncate(inbound, 80) : "Session";
+}
+export const MAX_NARRATIVE_TEXT = 4000;
+const MAX_MESSAGES = 200;
+const MAX_USER_MESSAGES = 200;
+const MAX_REASONING = 200;
+const MAX_STEP_TIMINGS = 200;
+export function capText(s, n = MAX_NARRATIVE_TEXT) {
+    return s.length > n ? `${s.slice(0, n - 1)}…` : s;
+}
+export const MAX_CONTEXT_SECTION_TEXT = 131_072;
+const MAX_CONTEXT_SECTIONS = 40;
+export function recordContext(sessionId, sections, at = new Date().toISOString()) {
+    const capped = sections
+        .filter((s) => s.label && s.text)
+        .slice(0, MAX_CONTEXT_SECTIONS)
+        .map((s) => ({
+        label: capText(s.label, 200),
+        text: capText(s.text, MAX_CONTEXT_SECTION_TEXT),
+    }));
+    if (capped.length === 0)
+        return;
+    appendPatch({ id: sessionId, at, t: "context", sections: capped });
+}
+export function recordContextStrict(sessionId, sections, at = new Date().toISOString()) {
+    const capped = sections
+        .filter((s) => s.label && s.text)
+        .slice(0, MAX_CONTEXT_SECTIONS)
+        .map((s) => ({
+        label: capText(s.label, 200),
+        text: capText(s.text, MAX_CONTEXT_SECTION_TEXT),
+    }));
+    if (capped.length === 0)
+        return;
+    appendPatchStrict({ id: sessionId, at, t: "context", sections: capped });
+}
+export function recordSystemAction(sessionId, input) {
+    const startedAt = input.startedAt ?? new Date().toISOString();
+    const endedAt = input.endedAt ?? new Date().toISOString();
+    const callId = input.callId ?? `sys_${randomUUID()}`;
+    const summary = redactValue(input.result, MAX_TOOL_STRING);
+    const payloadDocId = input.result !== undefined ? fullPayloadDocIdFor(input.result, summary) : undefined;
+    appendPatch({
+        id: sessionId,
+        at: startedAt,
+        t: "action_started",
+        callId,
+        tool: input.tool,
+        args: redactValue(input.args, MAX_TOOL_STRING),
+        system: true,
+    });
+    appendPatch({
+        id: sessionId,
+        at: endedAt,
+        t: "action_result",
+        callId,
+        tool: input.tool,
+        status: input.ok ? "completed" : "failed",
+        ok: input.ok,
+        resultSummary: summary,
+        ...(input.error !== undefined ? { error: input.error } : {}),
+        ...(payloadDocId ? { payloadDocId } : {}),
+    });
+}
+function emptyRow(id, at) {
+    return {
+        id,
+        source: {
+            kind: "unknown",
+            repo: null,
+            prNumber: null,
+            sender: null,
+            url: null,
+            continuationToken: null,
+        },
+        title: "Session",
+        status: "running",
+        stalled: false,
+        prompt: null,
+        summary: null,
+        channelKind: null,
+        model: null,
+        flow: null,
+        env: null,
+        trigger: null,
+        mode: null,
+        parentSessionId: null,
+        workflowFlow: null,
+        childCount: 0,
+        waitingTool: null,
+        waitingCallId: null,
+        approvalKind: null,
+        result: null,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        turns: 0,
+        actions: [],
+        stepTimings: [],
+        messages: [],
+        userMessages: [],
+        reasoning: [],
+        context: [],
+        error: null,
+        startedAt: at,
+        updatedAt: at,
+        completedAt: null,
+    };
+}
+function firstTime(seen, id, key) {
+    if (!seen)
+        return true;
+    let set = seen.get(id);
+    if (!set) {
+        set = new Set();
+        seen.set(id, set);
+    }
+    if (set.has(key))
+        return false;
+    set.add(key);
+    return true;
+}
+export function applyPatch(rows, p, seen) {
+    if (p.t === "row") {
+        rows.set(p.id, {
+            ...p.row,
+            context: p.row.context ?? [],
+            stepTimings: p.row.stepTimings ?? [],
+            userMessages: p.row.userMessages ?? [],
+            trigger: p.row.trigger ?? null,
+            mode: p.row.mode ?? null,
+            waitingCallId: p.row.waitingCallId ?? null,
+        });
+        return;
+    }
+    const row = rows.get(p.id) ?? emptyRow(p.id, p.at);
+    row.updatedAt = p.at;
+    switch (p.t) {
+        case "start": {
+            row.channelKind = p.channelKind ?? row.channelKind;
+            row.model = p.model ?? row.model;
+            row.flow = p.flow ?? row.flow;
+            row.env = p.env ?? row.env;
+            row.parentSessionId = p.parentSessionId ?? row.parentSessionId;
+            row.source = deriveSource(p.continuationToken ?? null, row.channelKind);
+            row.trigger = p.trigger ?? row.trigger ?? defaultTriggerFor(row.source.kind);
+            break;
+        }
+        case "inbound": {
+            if (row.prompt == null) {
+                if (row.source.kind === "mention" ||
+                    row.source.kind === "pr" ||
+                    row.source.kind === "review" ||
+                    row.source.kind === "journey_refine") {
+                    const gh = parseGithubInbound(p.text);
+                    if (gh.repo)
+                        row.source.repo = gh.repo;
+                    if (gh.sender)
+                        row.source.sender = gh.sender;
+                    if (gh.url)
+                        row.source.url = gh.url;
+                    if (gh.number != null)
+                        row.source.prNumber = gh.number;
+                    row.source.kind =
+                        gh.mode === "journey_refine"
+                            ? "journey_refine"
+                            : gh.mode === "review" || gh.isPrOpened
+                                ? "review"
+                                : "mention";
+                    row.mode = gh.mode ?? row.mode;
+                    row.prompt = gh.body;
+                }
+                else if (row.source.kind === "sentry") {
+                    const s = parseSentryInbound(p.text);
+                    if (s.repo)
+                        row.source.repo = s.repo;
+                    if (s.url)
+                        row.source.url = s.url;
+                    row.prompt = p.text.trim();
+                }
+                else if (row.source.kind === "unknown") {
+                    const gh = parseGithubInbound(p.text);
+                    if (gh.mode === "review" || gh.mode === "journey_refine") {
+                        if (gh.repo)
+                            row.source.repo = gh.repo;
+                        if (gh.number != null)
+                            row.source.prNumber = gh.number;
+                        row.source.kind = gh.mode === "journey_refine" ? "journey_refine" : "review";
+                        row.mode = gh.mode;
+                        row.prompt = gh.body;
+                    }
+                    else {
+                        row.prompt = p.text.trim();
+                    }
+                }
+                else {
+                    row.prompt = p.text.trim();
+                }
+                row.title = titleFor(row.source, p.text);
+            }
+            const userText = p.text.trim();
+            if (userText) {
+                row.userMessages.push({ at: p.at, text: capText(userText) });
+                if (row.userMessages.length > MAX_USER_MESSAGES)
+                    row.userMessages.shift();
+            }
+            if (row.status === "waiting")
+                row.status = "running";
+            break;
+        }
+        case "output": {
+            const text = p.text.trim();
+            if (text && (p.stepKey == null || firstTime(seen, p.id, `out:${p.stepKey}`))) {
+                row.summary = text;
+                row.turns += 1;
+                if (row.approvalKind !== null) {
+                    row.approvalKind = null;
+                    row.waitingTool = null;
+                    row.waitingCallId = null;
+                    if (row.status === "waiting")
+                        row.status = "running";
+                }
+                row.messages.push({
+                    at: p.at,
+                    text: capText(text),
+                    finishReason: p.finishReason ?? null,
+                    ...(p.stepKey ? { stepKey: p.stepKey } : {}),
+                });
+                if (row.messages.length > MAX_MESSAGES)
+                    row.messages.shift();
+            }
+            break;
+        }
+        case "reasoning": {
+            const text = p.text.trim();
+            if (text) {
+                row.reasoning.push({ at: p.at, text: capText(text) });
+                if (row.reasoning.length > MAX_REASONING)
+                    row.reasoning.shift();
+            }
+            break;
+        }
+        case "context": {
+            for (const s of p.sections) {
+                if (!s || typeof s.label !== "string" || typeof s.text !== "string")
+                    continue;
+                const section = { label: s.label, text: capText(s.text, MAX_CONTEXT_SECTION_TEXT) };
+                const i = row.context.findIndex((c) => c.label === section.label);
+                if (i >= 0)
+                    row.context[i] = section;
+                else if (row.context.length < MAX_CONTEXT_SECTIONS)
+                    row.context.push(section);
+            }
+            break;
+        }
+        case "action": {
+            row.actions.push({ tool: p.tool, status: p.status, at: p.at });
+            break;
+        }
+        case "action_started": {
+            const existing = row.actions.find((a) => a.callId === p.callId);
+            if (existing) {
+                existing.tool = p.tool;
+                existing.args = p.args;
+                existing.at = p.at;
+                existing.status = "running";
+                delete existing.ok;
+                delete existing.resultSummary;
+                delete existing.durationMs;
+                delete existing.error;
+                delete existing.payloadDocId;
+                break;
+            }
+            row.actions.push({
+                tool: p.tool,
+                callId: p.callId,
+                args: p.args,
+                at: p.at,
+                status: "running",
+                ...(p.system ? { system: true } : {}),
+            });
+            break;
+        }
+        case "action_result": {
+            const started = row.actions.find((a) => a.callId === p.callId && a.status === "running");
+            const target = started ??
+                (() => {
+                    const fresh = { tool: p.tool, callId: p.callId, at: p.at, status: "" };
+                    row.actions.push(fresh);
+                    return fresh;
+                })();
+            target.status = p.status;
+            target.ok = p.ok;
+            target.resultSummary = p.resultSummary;
+            if (p.error !== undefined)
+                target.error = p.error;
+            if (p.detail !== undefined)
+                target.detail = p.detail;
+            if (p.model !== undefined)
+                target.model = p.model;
+            if (p.usage !== undefined) {
+                target.usage = p.usage;
+                if (firstTime(seen, p.id, `ausg:${p.callId}`)) {
+                    row.inputTokens += p.usage.inputTokens ?? 0;
+                    row.outputTokens += p.usage.outputTokens ?? 0;
+                    row.cacheReadTokens += p.usage.cacheReadTokens ?? 0;
+                    row.cacheWriteTokens += p.usage.cacheWriteTokens ?? 0;
+                }
+            }
+            if (p.payloadDocId !== undefined)
+                target.payloadDocId = p.payloadDocId;
+            if (started) {
+                const ms = Date.parse(p.at) - Date.parse(started.at);
+                if (Number.isFinite(ms) && ms >= 0)
+                    target.durationMs = ms;
+            }
+            const resolvesPark = row.waitingCallId !== null ? p.callId === row.waitingCallId : p.tool === row.waitingTool;
+            if (row.approvalKind !== null && resolvesPark) {
+                row.approvalKind = null;
+                row.waitingTool = null;
+                row.waitingCallId = null;
+                if (row.status === "waiting")
+                    row.status = "running";
+            }
+            break;
+        }
+        case "waiting": {
+            if (row.status === "running")
+                row.status = "waiting";
+            break;
+        }
+        case "link": {
+            row.parentSessionId = p.parentSessionId ?? row.parentSessionId;
+            break;
+        }
+        case "waiting_meta": {
+            row.waitingTool = p.waitingTool;
+            row.waitingCallId = p.waitingCallId ?? null;
+            row.approvalKind = p.approvalKind;
+            break;
+        }
+        case "result": {
+            const redacted = redactValue(p.result);
+            row.result = typeof redacted === "string" ? redacted : JSON.stringify(redacted);
+            break;
+        }
+        case "usage": {
+            if (p.stepKey == null || firstTime(seen, p.id, `usg:${p.stepKey}`)) {
+                row.inputTokens += p.input ?? 0;
+                row.outputTokens += p.output ?? 0;
+                row.cacheReadTokens += p.cacheRead ?? 0;
+                row.cacheWriteTokens += p.cacheWrite ?? 0;
+            }
+            break;
+        }
+        case "step_timing": {
+            if (p.stepKey == null || firstTime(seen, p.id, `tim:${p.stepKey}`)) {
+                const started = Date.parse(p.startedAt);
+                const completed = Date.parse(p.at);
+                const first = p.firstTokenAt ? Date.parse(p.firstTokenAt) : Number.NaN;
+                const durationMs = completed - started;
+                const ttftMs = first - started;
+                const genMs = completed - first;
+                const tokensPerSec = p.outputTokens !== undefined && p.outputTokens > 0 && genMs > 0
+                    ? Math.round((p.outputTokens / (genMs / 1000)) * 10) / 10
+                    : undefined;
+                row.stepTimings.push({
+                    ...(p.stepKey ? { stepKey: p.stepKey } : {}),
+                    startedAt: p.startedAt,
+                    ...(p.firstTokenAt ? { firstTokenAt: p.firstTokenAt } : {}),
+                    completedAt: p.at,
+                    ...(Number.isFinite(durationMs) && durationMs >= 0 ? { durationMs } : {}),
+                    ...(Number.isFinite(ttftMs) && ttftMs >= 0 ? { ttftMs } : {}),
+                    ...(p.outputTokens !== undefined ? { outputTokens: p.outputTokens } : {}),
+                    ...(tokensPerSec !== undefined ? { tokensPerSec } : {}),
+                });
+                if (row.stepTimings.length > MAX_STEP_TIMINGS)
+                    row.stepTimings.shift();
+            }
+            break;
+        }
+        case "done": {
+            row.status = "done";
+            row.completedAt = p.at;
+            break;
+        }
+        case "failed": {
+            row.status = "failed";
+            row.error = p.message ?? p.code ?? "failed";
+            row.completedAt = p.at;
+            break;
+        }
+    }
+    rows.set(p.id, row);
+}
+export function compareSessionsDesc(a, b) {
+    return b.startedAt.localeCompare(a.startedAt) || b.id.localeCompare(a.id);
+}
+export function reduceSessions(patches) {
+    const rows = new Map();
+    const seen = new Map();
+    for (const p of patches)
+        applyPatch(rows, p, seen);
+    return [...rows.values()].sort(compareSessionsDesc);
+}
+export function readSessions(file = storePath()) {
+    return reduceSessions(readPatches(file));
+}
+let idx = null;
+export function __resetSessionIndex() {
+    idx = null;
+}
+function refreshIndex(file) {
+    if (!idx || idx.file !== file)
+        idx = { file, offset: 0, rows: new Map(), seen: new Map() };
+    let size;
+    try {
+        size = statSync(file).size;
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            idx.offset = 0;
+            idx.rows.clear();
+            idx.seen.clear();
+            return idx.rows;
+        }
+        throw err;
+    }
+    if (size < idx.offset) {
+        idx.offset = 0;
+        idx.rows.clear();
+        idx.seen.clear();
+    }
+    if (size > idx.offset) {
+        const fd = openSync(file, "r");
+        try {
+            const len = size - idx.offset;
+            const buf = Buffer.allocUnsafe(len);
+            const read = readSync(fd, buf, 0, len, idx.offset);
+            const text = buf.toString("utf8", 0, read);
+            const lastNl = text.lastIndexOf("\n");
+            if (lastNl < 0)
+                return idx.rows;
+            const complete = text.slice(0, lastNl);
+            for (const line of complete.split("\n")) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const p = JSON.parse(trimmed);
+                    if (p && typeof p.id === "string" && typeof p.t === "string")
+                        applyPatch(idx.rows, p, idx.seen);
+                }
+                catch {
+                    log.warn("skipping malformed patch line (index tail)");
+                }
+            }
+            idx.offset += Buffer.byteLength(complete, "utf8") + 1;
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    return idx.rows;
+}
+export function readSessionsIndexed(file = storePath()) {
+    return [...refreshIndex(file).values()].sort(compareSessionsDesc);
+}
+export const DEFAULT_PAGE_LIMIT = 50;
+export const MAX_PAGE_LIMIT = 200;
+const SESSION_STATUS_FILTERS = [
+    "active",
+    "parked",
+    "stalled",
+    "failed",
+    "prod",
+    "dev",
+];
+export function isSessionStatusFilter(v) {
+    return SESSION_STATUS_FILTERS.includes(v);
+}
+export function isActiveSession(r) {
+    if (r.status === "running")
+        return true;
+    if (r.status !== "waiting")
+        return false;
+    return r.approvalKind !== null || (r.turns === 0 && r.summary === null);
+}
+function matchesStatusFilter(r, f, isStalled) {
+    if (f === "active")
+        return isActiveSession(r);
+    if (f === "parked")
+        return r.approvalKind === "approval" && r.status !== "done" && r.status !== "failed";
+    if (f === "stalled")
+        return isStalled(r);
+    if (f === "failed")
+        return r.status === "failed";
+    if (f === "prod")
+        return r.env === "prod";
+    return r.env === "dev";
+}
+export const SESSION_FACETS = {
+    repo: (r) => r.source.repo,
+};
+export function isSessionFacet(v) {
+    return Object.hasOwn(SESSION_FACETS, v);
+}
+const CHAT_SOURCE_KINDS = new Set([
+    "web",
+    "email",
+    "telegram",
+    "fixit",
+]);
+const HEALTH_PING_MARKER = "CI health ping:";
+export function isChatSession(r) {
+    if (!CHAT_SOURCE_KINDS.has(r.source.kind))
+        return false;
+    return !(r.source.kind === "web" &&
+        ((r.title ?? "").startsWith(HEALTH_PING_MARKER) ||
+            (r.prompt ?? "").startsWith(HEALTH_PING_MARKER)));
+}
+export function encodeCursor(r) {
+    return Buffer.from(`${r.startedAt}|${r.id}`, "utf8").toString("base64");
+}
+export function decodeCursor(c) {
+    try {
+        const s = Buffer.from(c, "base64").toString("utf8");
+        const i = s.indexOf("|");
+        if (i <= 0 || i >= s.length - 1)
+            return null;
+        return { startedAt: s.slice(0, i), id: s.slice(i + 1) };
+    }
+    catch {
+        return null;
+    }
+}
+export function parseSessionsQuery(rawUrl) {
+    let limit;
+    let before;
+    let view;
+    let root;
+    let flow;
+    let status;
+    let groupBy;
+    let group;
+    let scope;
+    try {
+        const u = new URL(rawUrl, "http://localhost");
+        const l = u.searchParams.get("limit");
+        if (l != null) {
+            const n = Number(l);
+            if (Number.isFinite(n))
+                limit = n;
+        }
+        const b = u.searchParams.get("before");
+        if (b)
+            before = b;
+        const v = u.searchParams.get("view");
+        if (v === "top" || v === "all" || v === "approvals")
+            view = v;
+        const r = u.searchParams.get("root");
+        if (r)
+            root = r;
+        const fl = u.searchParams.get("flow");
+        if (fl)
+            flow = fl;
+        const st = u.searchParams.get("status");
+        if (st && isSessionStatusFilter(st))
+            status = st;
+        const gb = u.searchParams.get("groupBy");
+        if (gb && isSessionFacet(gb))
+            groupBy = gb;
+        const g = u.searchParams.get("group");
+        if (g)
+            group = g;
+        if (u.searchParams.get("scope") === "chat")
+            scope = "chat";
+    }
+    catch {
+    }
+    const out = {
+        limit,
+        before,
+    };
+    if (view !== undefined)
+        out.view = view;
+    if (root !== undefined)
+        out.root = root;
+    if (flow !== undefined)
+        out.flow = flow;
+    if (status !== undefined)
+        out.status = status;
+    if (groupBy !== undefined)
+        out.groupBy = groupBy;
+    if (group !== undefined)
+        out.group = group;
+    if (scope !== undefined)
+        out.scope = scope;
+    return out;
+}
+export function collectTree(rows, rootId) {
+    const childrenByParent = new Map();
+    for (const r of rows) {
+        if (r.parentSessionId != null) {
+            const list = childrenByParent.get(r.parentSessionId) ?? [];
+            list.push(r.id);
+            childrenByParent.set(r.parentSessionId, list);
+        }
+    }
+    const wanted = new Set([rootId]);
+    const queue = [rootId];
+    for (let head = 0; head < queue.length; head++) {
+        for (const child of childrenByParent.get(queue[head]) ?? []) {
+            if (!wanted.has(child)) {
+                wanted.add(child);
+                queue.push(child);
+            }
+        }
+    }
+    return wanted;
+}
+export function isApprovalParked(r) {
+    return r.status !== "done" && r.status !== "failed" && r.approvalKind === "approval";
+}
+export function dismissSession(id, file = storePath()) {
+    const row = readSessionsIndexed(file).find((r) => r.id === id);
+    if (!row || row.status === "done" || row.status === "failed")
+        return false;
+    const patch = {
+        id,
+        at: new Date().toISOString(),
+        t: "failed",
+        code: "expired",
+        message: "dismissed by operator",
+    };
+    mkdirSync(dirname(file), { recursive: true });
+    appendFileSync(file, `${JSON.stringify(patch)}\n`);
+    return true;
+}
+export function readSessionsPage(opts = {}, file = storePath(), processBootMs = Date.now() - process.uptime() * 1000) {
+    const raw = Number(opts.limit);
+    const limit = Number.isFinite(raw)
+        ? Math.min(Math.max(1, Math.floor(raw)), MAX_PAGE_LIMIT)
+        : DEFAULT_PAGE_LIMIT;
+    let allRows;
+    try {
+        allRows = readSessionsIndexed(file);
+    }
+    catch (err) {
+        log.error({ err }, "index refresh failed; full-fold fallback");
+        allRows = readSessions(file);
+    }
+    const isStalled = (r) => r.status === "running" && Date.parse(r.updatedAt) < processBootMs;
+    const stalledCount = allRows.reduce((n, r) => n + (isStalled(r) ? 1 : 0), 0);
+    const byId = new Map(allRows.map((r) => [r.id, r]));
+    const rootIdOf = (r) => {
+        let cur = r;
+        const seen = new Set([cur.id]);
+        while (cur.parentSessionId && byId.has(cur.parentSessionId) && !seen.has(cur.parentSessionId)) {
+            cur = byId.get(cur.parentSessionId);
+            seen.add(cur.id);
+        }
+        return cur.id;
+    };
+    const parkedRoots = new Set();
+    for (const r of allRows)
+        if (isApprovalParked(r))
+            parkedRoots.add(rootIdOf(r));
+    const pendingApprovalCount = parkedRoots.size;
+    if (opts.view === "approvals") {
+        const wanted = new Set();
+        for (const r of allRows) {
+            if (!isApprovalParked(r))
+                continue;
+            let cur = r;
+            const seen = new Set();
+            while (cur && !seen.has(cur.id)) {
+                wanted.add(cur.id);
+                seen.add(cur.id);
+                cur = cur.parentSessionId ? byId.get(cur.parentSessionId) : undefined;
+            }
+        }
+        const sessions = allRows
+            .filter((r) => wanted.has(r.id))
+            .map((r) => ({ ...r, stalled: Date.parse(r.updatedAt) < processBootMs }));
+        return { sessions, nextCursor: null, hasMore: false, stalledCount, pendingApprovalCount };
+    }
+    if (opts.root) {
+        const wanted = collectTree(allRows, opts.root);
+        const sessions = allRows
+            .filter((r) => wanted.has(r.id))
+            .map((r) => ({ ...r, stalled: isStalled(r) }));
+        return { sessions, nextCursor: null, hasMore: false, stalledCount, pendingApprovalCount };
+    }
+    let rows = allRows;
+    let flows;
+    let groups;
+    if (opts.view === "top") {
+        const childrenByParent = new Map();
+        for (const r of allRows) {
+            if (r.parentSessionId != null) {
+                const list = childrenByParent.get(r.parentSessionId) ?? [];
+                list.push(r);
+                childrenByParent.set(r.parentSessionId, list);
+            }
+        }
+        rows = allRows
+            .filter((r) => r.parentSessionId == null)
+            .map((r) => {
+            const kids = (childrenByParent.get(r.id) ?? []).slice().sort(compareSessionsDesc).reverse();
+            return {
+                ...r,
+                childCount: kids.length,
+                workflowFlow: kids.find((k) => k.flow != null)?.flow ?? r.flow ?? null,
+                approvalKind: parkedRoots.has(r.id) ? "approval" : r.approvalKind,
+            };
+        });
+        flows = {};
+        for (const r of rows) {
+            if (r.workflowFlow)
+                flows[r.workflowFlow] = (flows[r.workflowFlow] ?? 0) + 1;
+        }
+        if (opts.scope === "chat")
+            rows = rows.filter(isChatSession);
+        if (opts.flow)
+            rows = rows.filter((r) => r.workflowFlow === opts.flow);
+        if (opts.groupBy && isSessionFacet(opts.groupBy)) {
+            const facetOf = SESSION_FACETS[opts.groupBy];
+            groups = {};
+            for (const r of rows) {
+                const v = facetOf(r);
+                if (v)
+                    groups[v] = (groups[v] ?? 0) + 1;
+            }
+            if (opts.group)
+                rows = rows.filter((r) => facetOf(r) === opts.group);
+        }
+    }
+    const counts = {
+        all: rows.length,
+        active: 0,
+        parked: 0,
+        stalled: 0,
+        failed: 0,
+        prod: 0,
+        dev: 0,
+    };
+    for (const r of rows) {
+        if (isActiveSession(r))
+            counts.active++;
+        if (r.approvalKind === "approval" && r.status !== "done" && r.status !== "failed")
+            counts.parked++;
+        if (isStalled(r))
+            counts.stalled++;
+        if (r.status === "failed")
+            counts.failed++;
+        if (r.env === "prod")
+            counts.prod++;
+        else if (r.env === "dev")
+            counts.dev++;
+    }
+    if (opts.status && opts.view === "top") {
+        rows = rows.filter((r) => matchesStatusFilter(r, opts.status, isStalled));
+    }
+    let start = 0;
+    if (opts.before) {
+        const c = decodeCursor(opts.before);
+        if (c) {
+            const i = rows.findIndex((r) => r.startedAt < c.startedAt || (r.startedAt === c.startedAt && r.id < c.id));
+            start = i < 0 ? rows.length : i;
+        }
+    }
+    const LIST_PROMPT_CAP = 500;
+    const trimForList = (r) => opts.view === "top"
+        ? {
+            ...r,
+            actions: r.actions.map((a) => ({ tool: a.tool, status: a.status, at: a.at })),
+            context: [],
+            stepTimings: [],
+            userMessages: [],
+            prompt: r.prompt && r.prompt.length > LIST_PROMPT_CAP
+                ? r.prompt.slice(0, LIST_PROMPT_CAP)
+                : r.prompt,
+        }
+        : r;
+    const sessions = rows
+        .slice(start, start + limit)
+        .map((r) => ({ ...trimForList(r), stalled: isStalled(r) }));
+    const hasMore = start + limit < rows.length;
+    const nextCursor = hasMore && sessions.length ? encodeCursor(sessions[sessions.length - 1]) : null;
+    return {
+        sessions,
+        nextCursor,
+        hasMore,
+        stalledCount,
+        pendingApprovalCount,
+        counts,
+        flows,
+        groups,
+    };
+}
+//# sourceMappingURL=recorder.js.map