@ericsanchezok/synergy-workbench 0.0.0-stage → 3.1.0

package/dist/execution/content.js

@@ -0,0 +1,184 @@
+import { ExecutionQueryError, queryCursor } from "./query.js";
+import { z } from "zod";
+import { RuntimeContext } from "@ericsanchezok/synergy-harness/lifecycle/context";
+import { ExecutionJson } from "./json-sections.js";
+import { ScopeContext } from "@ericsanchezok/synergy-harness/scope/context";
+export var ExecutionContent;
+(function (ExecutionContent) {
+    ExecutionContent.Query = z.object({
+        field: z.string().min(1).max(100),
+        runID: z.string().optional(),
+        version: z.string().max(4096).optional(),
+    });
+    ExecutionContent.PageQuery = ExecutionContent.Query.extend({
+        cursor: z.string().max(4096).optional(),
+        limit: z.coerce.number().int().min(1).max(500).default(100),
+    });
+    ExecutionContent.SearchQuery = ExecutionContent.PageQuery.extend({
+        query: z.string().min(1).max(500),
+        caseSensitive: z.preprocess((value) => (value === "false" ? false : value), z.coerce.boolean()).default(true),
+    });
+    ExecutionContent.Section = z.object({
+        path: z.array(z.string()),
+        kind: z.enum(["object", "array", "string", "number", "boolean", "null"]),
+        offset: z.number(),
+        bytes: z.number(),
+        role: z.string().optional(),
+        preview: z.string(),
+    });
+    ExecutionContent.Sections = z
+        .object({
+        contentVersion: z.string(),
+        format: z.enum(["json", "text", "partial"]),
+        items: z.array(ExecutionContent.Section),
+        total: z.number(),
+        nextCursor: z.string().nullable(),
+        truncated: z.boolean(),
+    })
+        .meta({ ref: "ExecutionContentSections" });
+    ExecutionContent.Search = z
+        .object({
+        contentVersion: z.string(),
+        status: z.enum(["partial", "complete"]),
+        items: z.array(z.object({ offset: z.number(), bytes: z.number(), preview: z.string() })),
+        nextCursor: z.string().nullable(),
+    })
+        .meta({ ref: "ExecutionContentSearch" });
+    const cache = RuntimeContext.state(() => ({
+        entries: new Map(),
+        bytes: 0,
+    }));
+    function cursor(version, query, offset) {
+        return Buffer.from(JSON.stringify({ version, query, offset })).toString("base64url");
+    }
+    function position(input, version, query) {
+        if (!input)
+            return 0;
+        const value = queryCursor(z.object({ version: z.string(), query: z.string(), offset: z.number().int().nonnegative() }), input);
+        if (value.version !== version || value.query !== query)
+            throw new ExecutionQueryError("Execution content cursor does not match its version and query");
+        return value.offset;
+    }
+    async function sections(source, input, signal) {
+        const offset = position(input.cursor, source.contentVersion, "sections");
+        if (source.status === "partial" || !source.mediaType.includes("json"))
+            return ExecutionContent.Sections.parse({
+                contentVersion: source.contentVersion,
+                format: source.status === "partial" ? "partial" : "text",
+                items: [],
+                total: 0,
+                nextCursor: null,
+                truncated: false,
+            });
+        const state = cache();
+        const key = ScopeContext.current.scope.id + ":" + source.contentVersion;
+        let value = state.entries.get(key)?.value;
+        if (!value) {
+            try {
+                value = await ExecutionJson.index(source.stream(), signal);
+            }
+            catch (error) {
+                if (!(error instanceof SyntaxError))
+                    throw error;
+                return ExecutionContent.Sections.parse({
+                    contentVersion: source.contentVersion,
+                    format: "text",
+                    items: [],
+                    total: 0,
+                    nextCursor: null,
+                    truncated: false,
+                });
+            }
+            const bytes = Buffer.byteLength(JSON.stringify(value));
+            if (!state.entries.has(key) && bytes <= 8 * 1024 * 1024) {
+                while (state.bytes + bytes > 8 * 1024 * 1024 && state.entries.size) {
+                    const [key, entry] = state.entries.entries().next().value;
+                    state.entries.delete(key);
+                    state.bytes -= entry.bytes;
+                }
+                state.entries.set(key, { value, bytes });
+                state.bytes += bytes;
+            }
+        }
+        const items = value.items.slice(offset, offset + input.limit);
+        return ExecutionContent.Sections.parse({
+            contentVersion: source.contentVersion,
+            format: "json",
+            items,
+            total: value.items.length,
+            nextCursor: offset + items.length < value.items.length
+                ? cursor(source.contentVersion, "sections", offset + items.length)
+                : null,
+            truncated: value.truncated,
+        });
+    }
+    ExecutionContent.sections = sections;
+    async function value(source, path, signal) {
+        let next;
+        let section;
+        do {
+            const page = await sections(source, ExecutionContent.PageQuery.parse({ field: "request", cursor: next, limit: 500 }), signal);
+            section = page.items.find((item) => JSON.stringify(item.path) === JSON.stringify(path));
+            next = page.nextCursor ?? undefined;
+        } while (!section && next);
+        if (!section || section.bytes > 8 * 1024 * 1024)
+            return undefined;
+        const parts = [];
+        for (let offset = section.offset; offset < section.offset + section.bytes;) {
+            signal?.throwIfAborted();
+            const page = await source.read(offset, Math.min(65_536, section.offset + section.bytes - offset));
+            parts.push(page.text);
+            offset = page.nextOffset ?? source.bytes;
+        }
+        return JSON.parse(parts.join(""));
+    }
+    ExecutionContent.value = value;
+    async function search(source, input, signal) {
+        const fingerprint = JSON.stringify([input.query, input.caseSensitive]);
+        let offset = position(input.cursor, source.contentVersion, fingerprint);
+        const pattern = new RegExp(input.query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), input.caseSensitive ? "gu" : "giu");
+        const items = [];
+        let carry = "";
+        let carryOffset = offset;
+        let next = null;
+        while (offset < source.bytes) {
+            signal?.throwIfAborted();
+            const page = await source.read(offset, 65_536);
+            const text = carry + page.text;
+            const base = carry ? carryOffset : offset;
+            const safe = page.nextOffset === null ? text.length : Math.max(0, text.length - input.query.length - 2);
+            pattern.lastIndex = 0;
+            let consumed = 0;
+            for (let match = pattern.exec(text); match && match.index < safe; match = pattern.exec(text)) {
+                const start = base + Buffer.byteLength(text.slice(0, match.index));
+                const bytes = Buffer.byteLength(match[0]);
+                items.push({
+                    offset: start,
+                    bytes,
+                    preview: text.slice(Math.max(0, match.index - 60), match.index + match[0].length + 100),
+                });
+                consumed = match.index + match[0].length;
+                if (items.length === input.limit) {
+                    next = start + bytes;
+                    break;
+                }
+            }
+            if (next !== null)
+                break;
+            let retained = Math.max(safe, consumed);
+            if (retained && retained < text.length && /[\uDC00-\uDFFF]/.test(text[retained]))
+                retained--;
+            carry = text.slice(retained);
+            carryOffset = base + Buffer.byteLength(text.slice(0, retained));
+            offset = page.nextOffset ?? source.bytes;
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        return ExecutionContent.Search.parse({
+            contentVersion: source.contentVersion,
+            status: source.status,
+            items,
+            nextCursor: next !== null && next < source.bytes ? cursor(source.contentVersion, fingerprint, next) : null,
+        });
+    }
+    ExecutionContent.search = search;
+})(ExecutionContent || (ExecutionContent = {}));

package/dist/execution/json-sections.js

@@ -0,0 +1,231 @@
+export var ExecutionJson;
+(function (ExecutionJson) {
+    async function index(source, signal) {
+        const stack = [];
+        const items = [];
+        let token;
+        let offset = 0;
+        let done = false;
+        let truncated = false;
+        let indexBytes = 0;
+        const utf8 = new TextDecoder("utf-8", { fatal: true });
+        const invalid = () => {
+            throw new SyntaxError("Execution content is not complete JSON");
+        };
+        const path = () => {
+            const parent = stack.at(-1);
+            if (!parent)
+                return [];
+            return [...parent.path, parent.kind === "array" ? String(parent.index) : parent.key];
+        };
+        const finishValue = () => {
+            const parent = stack.at(-1);
+            if (!parent) {
+                done = true;
+                return;
+            }
+            if (parent.state !== "value")
+                invalid();
+            parent.state = "comma";
+            parent.empty = false;
+            parent.index++;
+        };
+        const sectionBytes = (value) => 96 + value.path.reduce((sum, key) => sum + key.length * 4, 0) + value.preview.length * 4;
+        const section = (value) => {
+            if (value.path.length > 2)
+                return;
+            const bytes = sectionBytes(value);
+            while (value.path.length <= 1 && (items.length >= 10_000 || indexBytes + bytes > 2 * 1024 * 1024)) {
+                const index = items.findLastIndex((item) => item.path.length > 1);
+                if (index < 0)
+                    break;
+                indexBytes -= sectionBytes(items[index]);
+                items.splice(index, 1);
+                truncated = true;
+            }
+            if (items.length >= 10_000 || indexBytes + bytes > 2 * 1024 * 1024) {
+                truncated = true;
+                return;
+            }
+            indexBytes += bytes;
+            items.push(value);
+        };
+        const finishToken = (end) => {
+            const current = token;
+            const raw = Buffer.from(current.sample).toString();
+            if (current.key) {
+                if (current.overflow)
+                    throw new RangeError("Execution JSON key exceeds the section index budget");
+                stack.at(-1).key = JSON.parse(raw);
+                stack.at(-1).state = "colon";
+            }
+            else {
+                let kind = "string";
+                let preview = "";
+                if (current.kind === "scalar") {
+                    if (current.overflow || !/^(?:null|true|false|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)$/.test(raw))
+                        invalid();
+                    kind = raw === "null" ? "null" : raw === "true" || raw === "false" ? "boolean" : "number";
+                    preview = raw;
+                }
+                else if (!current.overflow) {
+                    const value = JSON.parse(raw);
+                    if (typeof value === "string")
+                        preview = value.slice(0, 160);
+                    if (current.path.at(-1) === "role" && typeof value === "string")
+                        stack.at(-1).role = value.slice(0, 64);
+                }
+                section({ path: current.path, kind, offset: current.start, bytes: end - current.start, preview });
+                finishValue();
+            }
+            token = undefined;
+        };
+        const sample = (byte) => {
+            const current = token;
+            const budget = current.key ? 65_536 : current.kind === "scalar" ? 1024 : 512;
+            if (current.sample.length < budget)
+                current.sample.push(byte);
+            else
+                current.overflow = true;
+        };
+        const consume = (byte) => {
+            if (token) {
+                if (token.kind === "scalar") {
+                    if (byte === 32 || byte === 9 || byte === 10 || byte === 13 || byte === 44 || byte === 93 || byte === 125) {
+                        finishToken(offset);
+                        return false;
+                    }
+                    sample(byte);
+                    return true;
+                }
+                sample(byte);
+                if (token.unicode) {
+                    if (!((byte >= 48 && byte <= 57) || (byte >= 65 && byte <= 70) || (byte >= 97 && byte <= 102)))
+                        invalid();
+                    token.unicode--;
+                }
+                else if (token.escaped) {
+                    if (byte === 117)
+                        token.unicode = 4;
+                    else if (![34, 92, 47, 98, 102, 110, 114, 116].includes(byte))
+                        invalid();
+                    token.escaped = false;
+                }
+                else if (byte === 92)
+                    token.escaped = true;
+                else if (byte === 34)
+                    finishToken(offset + 1);
+                else if (byte < 32)
+                    invalid();
+                return true;
+            }
+            if (byte === 32 || byte === 9 || byte === 10 || byte === 13)
+                return true;
+            if (done)
+                invalid();
+            const parent = stack.at(-1);
+            if (byte === 125 || byte === 93) {
+                if (!parent ||
+                    parent.kind !== (byte === 125 ? "object" : "array") ||
+                    !(parent.state === "comma" || (parent.empty && parent.state === (parent.kind === "object" ? "key" : "value"))))
+                    invalid();
+                const frame = stack.pop();
+                section({
+                    path: frame.path,
+                    kind: frame.kind,
+                    offset: frame.start,
+                    bytes: offset + 1 - frame.start,
+                    role: frame.role,
+                    preview: "",
+                });
+                finishValue();
+                return true;
+            }
+            if (parent?.state === "comma") {
+                if (byte !== 44)
+                    invalid();
+                parent.state = parent.kind === "object" ? "key" : "value";
+                return true;
+            }
+            if (parent?.state === "colon") {
+                if (byte !== 58)
+                    invalid();
+                parent.state = "value";
+                return true;
+            }
+            if (parent?.state === "key") {
+                if (byte !== 34)
+                    invalid();
+                token = {
+                    start: offset,
+                    path: parent.path,
+                    kind: "string",
+                    key: true,
+                    escaped: false,
+                    unicode: 0,
+                    sample: [byte],
+                    overflow: false,
+                };
+                return true;
+            }
+            if (parent && parent.state !== "value")
+                invalid();
+            const currentPath = path();
+            if (byte === 123 || byte === 91) {
+                if (stack.length >= 128)
+                    throw new RangeError("Execution JSON nesting exceeds the section index budget");
+                stack.push({
+                    path: currentPath,
+                    kind: byte === 123 ? "object" : "array",
+                    start: offset,
+                    state: byte === 123 ? "key" : "value",
+                    empty: true,
+                    index: 0,
+                });
+            }
+            else if (byte === 34) {
+                token = {
+                    start: offset,
+                    path: currentPath,
+                    kind: "string",
+                    key: false,
+                    escaped: false,
+                    unicode: 0,
+                    sample: [byte],
+                    overflow: false,
+                };
+            }
+            else {
+                if (!(byte === 45 || (byte >= 48 && byte <= 57) || byte === 116 || byte === 102 || byte === 110))
+                    invalid();
+                token = {
+                    start: offset,
+                    path: currentPath,
+                    kind: "scalar",
+                    key: false,
+                    escaped: false,
+                    unicode: 0,
+                    sample: [byte],
+                    overflow: false,
+                };
+            }
+            return true;
+        };
+        for await (const chunk of source) {
+            signal?.throwIfAborted();
+            utf8.decode(chunk, { stream: true });
+            for (const byte of chunk) {
+                while (!consume(byte)) { }
+                offset++;
+            }
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        utf8.decode();
+        if (token?.kind === "scalar")
+            finishToken(offset);
+        if (token || stack.length || !done)
+            invalid();
+        return { items: items.toSorted((a, b) => a.offset - b.offset || b.bytes - a.bytes), truncated };
+    }
+    ExecutionJson.index = index;
+})(ExecutionJson || (ExecutionJson = {}));

package/dist/execution/presentation.js

@@ -0,0 +1,79 @@
+import { z } from "zod";
+import { RolloutAccounting } from "@ericsanchezok/synergy-harness/rollout";
+export var ExecutionPresentation;
+(function (ExecutionPresentation) {
+    const Estimate = z.object({
+        basis: z.enum(["api", "unclassified", "subscription", "historical"]),
+        currency: z.literal("USD"),
+        known: z.number(),
+        maximum: z.number(),
+        unknown: z.number().int().nonnegative(),
+    });
+    ExecutionPresentation.Cost = z
+        .object({
+        state: z.enum(["unrecorded", "local", "subscription", "reported", "estimated", "mixed", "partial", "unknown"]),
+        reported: z.array(z.object({ currency: z.string(), amount: z.number() })),
+        estimates: z.array(Estimate),
+        equivalent: Estimate.nullable(),
+        missing: z.number().int().nonnegative(),
+        historical: z.number().int().nonnegative(),
+        knownUSD: z.number(),
+    })
+        .meta({ ref: "ExecutionCostPresentation" });
+    function cost(summary) {
+        const reported = Object.entries(summary.reported.currencies)
+            .toSorted(([a], [b]) => a.localeCompare(b))
+            .map(([currency, amount]) => ({ currency, amount }));
+        const coverage = summary.costCoverage;
+        const estimates = [];
+        const entry = (basis, metric, maximum = metric.known) => ({ basis, currency: "USD", known: metric.known, maximum, unknown: metric.unknown });
+        if (coverage) {
+            for (const basis of ["api", "unclassified"]) {
+                const bucket = coverage[basis];
+                if ((bucket.unreportedRequests ??
+                    Number(bucket.attempts && (bucket.unreported.known || bucket.unreported.unknown || !reported.length))) > 0)
+                    estimates.push(entry(basis, bucket.unreported, bucket.maximum.known));
+            }
+        }
+        const historicalAmount = (coverage
+            ? (coverage.historicalAmount ?? 0)
+            : !reported.length
+                ? summary.apiEstimate.known + summary.unclassifiedEquivalent.known
+                : 0) + summary.legacy.cost;
+        if (historicalAmount)
+            estimates.push(entry("historical", { known: historicalAmount, total: historicalAmount, unknown: 0 }));
+        const equivalent = coverage?.subscription.attempts
+            ? entry("subscription", summary.subscriptionEquivalent, summary.subscriptionEquivalent.known +
+                Math.max(0, coverage.subscription.maximum.known - coverage.subscription.unreported.known))
+            : null;
+        const historical = coverage
+            ? coverage.historical + summary.legacy.messages
+            : summary.attempts + summary.unobservedCalls + summary.legacy.messages;
+        const missing = estimates.reduce((count, estimate) => count + estimate.unknown, historical);
+        const state = missing
+            ? reported.length || estimates.some((estimate) => estimate.known)
+                ? "partial"
+                : "unknown"
+            : reported.length
+                ? estimates.length
+                    ? "mixed"
+                    : "reported"
+                : estimates.length
+                    ? "estimated"
+                    : equivalent
+                        ? "subscription"
+                        : coverage?.local
+                            ? "local"
+                            : "unrecorded";
+        return {
+            state,
+            reported,
+            estimates,
+            equivalent,
+            missing,
+            historical,
+            knownUSD: RolloutAccounting.knownExpense(summary),
+        };
+    }
+    ExecutionPresentation.cost = cost;
+})(ExecutionPresentation || (ExecutionPresentation = {}));

package/dist/execution/preview.js

@@ -0,0 +1,13 @@
+// Provenance: ../../../../docs/decisions/implemented/bug-fix/2026-10-22-detach-execution-previews.md
+// Local adaptation: build bounded UTF-16 output without retaining source-string backing storage.
+export function preview(value) {
+    const codes = [];
+    let whitespace = false;
+    for (let index = 0; index < value.length && codes.length < 240; index++) {
+        const space = /\s/.test(value[index]);
+        if (!space || !whitespace)
+            codes.push(space ? 32 : value.charCodeAt(index));
+        whitespace = space;
+    }
+    return String.fromCharCode(...codes);
+}

package/dist/execution/process.js

@@ -0,0 +1,125 @@
+export var ExecutionProcess;
+(function (ExecutionProcess) {
+    function auxiliaryKey(node) {
+        if (node.evidenceKind !== "call" || node.kind === "compaction")
+            return;
+        if (node.usageRole !== "auxiliary" && (!node.modelKind || node.modelKind === "chat"))
+            return;
+        return JSON.stringify([node.sessionID, node.runID, node.modelKind ?? "chat", node.purpose?.trim() || null]);
+    }
+    function auxiliaryMembers(nodes, node) {
+        const key = auxiliaryKey(node);
+        return key
+            ? nodes
+                .filter((row) => auxiliaryKey(row) === key)
+                .toSorted((a, b) => a.started - b.started || a.id.localeCompare(b.id))
+            : [];
+    }
+    ExecutionProcess.auxiliaryMembers = auxiliaryMembers;
+    function project(nodes, mode, root) {
+        const byID = new Map(nodes.map((node) => [node.id, node]));
+        const children = new Map();
+        const auxiliary = new Map();
+        for (const node of nodes) {
+            const key = auxiliaryKey(node);
+            if (key) {
+                const rows = auxiliary.get(key) ?? [];
+                rows.push(node);
+                auxiliary.set(key, rows);
+            }
+            if (!node.parentID)
+                continue;
+            const rows = children.get(node.parentID) ?? [];
+            rows.push(node);
+            children.set(node.parentID, rows);
+        }
+        const groups = new Map(nodes
+            .filter((node) => node.evidenceKind === "call")
+            .map((node) => {
+            const members = children.get(node.id) ?? [];
+            const attempts = members.filter((child) => child.evidenceKind === "attempt");
+            return [
+                node.id,
+                {
+                    id: node.id,
+                    started: node.started,
+                    callCount: 1,
+                    memberCount: members.length,
+                    attemptCount: attempts.length,
+                    retryCount: attempts.filter((attempt) => (attempt.attemptIndex ?? 0) > 0).length,
+                    anomalies: members.filter((child) => ["failed", "cancelled", "interrupted"].includes(child.status))
+                        .length,
+                    purpose: node.purpose?.trim() || null,
+                },
+            ];
+        }));
+        const heads = new Map();
+        const hidden = new Set();
+        if (mode === "process")
+            for (const members of auxiliary.values()) {
+                if (members.length < 2)
+                    continue;
+                members.sort((a, b) => a.started - b.started || a.id.localeCompare(b.id));
+                const first = members[0];
+                for (const member of members.slice(1))
+                    hidden.add(member.id);
+                const counters = members.map((node) => groups.get(node.id));
+                const status = members.some((node) => node.status === "running")
+                    ? "running"
+                    : (members.find((node) => ["failed", "cancelled", "interrupted", "unknown"].includes(node.status))?.status ??
+                        "completed");
+                heads.set(first.id, {
+                    ...first,
+                    status,
+                    ended: members.every((node) => node.ended !== undefined)
+                        ? Math.max(...members.map((node) => node.ended))
+                        : undefined,
+                    group: {
+                        id: first.id,
+                        started: first.started,
+                        callCount: members.length,
+                        memberCount: counters.reduce((sum, value) => sum + value.memberCount, 0),
+                        attemptCount: counters.reduce((sum, value) => sum + value.attemptCount, 0),
+                        retryCount: counters.reduce((sum, value) => sum + value.retryCount, 0),
+                        anomalies: counters.reduce((sum, value) => sum + value.anomalies, 0),
+                        purpose: first.purpose?.trim() || null,
+                    },
+                });
+            }
+        return nodes
+            .filter((node) => {
+            if (mode === "records")
+                return true;
+            if (hidden.has(node.id))
+                return false;
+            if (node.evidenceKind === "attempt")
+                return (node.attemptIndex ?? 0) > 0;
+            if (node.evidenceKind !== "call" || node.kind === "compaction" || auxiliaryKey(node))
+                return true;
+            return !(children.get(node.id) ?? []).some((child) => ["reasoning", "output", "tool"].includes(child.kind));
+        })
+            .map((original) => {
+            const node = heads.get(original.id) ?? original;
+            const ancestors = [];
+            const seen = new Set([node.id]);
+            let parent = node.parentID && byID.get(node.parentID);
+            while (parent && !seen.has(parent.id)) {
+                seen.add(parent.id);
+                ancestors.unshift({ id: parent.id, title: parent.title, kind: parent.kind });
+                parent = parent.parentID && byID.get(parent.parentID);
+            }
+            const rootRunID = !root || node.sessionID === root
+                ? node.runID
+                : (ancestors.map((ancestor) => byID.get(ancestor.id)).find((ancestor) => ancestor?.sessionID === root)
+                    ?.runID ?? null);
+            return {
+                ...node,
+                ancestors,
+                rootRunID,
+                attribution: node.attribution ?? (rootRunID === null ? "unassigned" : "known"),
+                group: node.group ?? groups.get(node.id) ?? (node.parentID ? groups.get(node.parentID) : undefined),
+            };
+        });
+    }
+    ExecutionProcess.project = project;
+})(ExecutionProcess || (ExecutionProcess = {}));