@ericsanchezok/synergy-workbench 0.0.0-stage → 3.1.1

package/src/execution/json-sections.ts

@@ -0,0 +1,230 @@
+export namespace ExecutionJson {
+  export type Section = {
+    path: string[]
+    kind: "object" | "array" | "string" | "number" | "boolean" | "null"
+    offset: number
+    bytes: number
+    role?: string
+    preview: string
+  }
+  type Frame = {
+    path: string[]
+    kind: "object" | "array"
+    start: number
+    state: "key" | "colon" | "value" | "comma"
+    empty: boolean
+    key?: string
+    index: number
+    role?: string
+  }
+  type Token = {
+    start: number
+    path: string[]
+    key: boolean
+    kind: "string" | "scalar"
+    escaped: boolean
+    unicode: number
+    sample: number[]
+    overflow: boolean
+  }
+
+  export async function index(source: AsyncIterable<Uint8Array>, signal?: AbortSignal) {
+    const stack: Frame[] = []
+    const items: Section[] = []
+    let token: Token | undefined
+    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: Section) =>
+      96 + value.path.reduce((sum, key) => sum + key.length * 4, 0) + value.preview.length * 4
+    const section = (value: Section) => {
+      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: number) => {
+      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: Section["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: unknown = 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: number) => {
+      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: number): boolean => {
+      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<void>((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 }
+  }
+}

package/src/execution/presentation.ts

@@ -0,0 +1,91 @@
+import { z } from "zod"
+import { RolloutAccounting } from "@ericsanchezok/synergy-harness/rollout"
+
+export namespace 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(),
+  })
+  export const 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" })
+  export type Cost = z.infer<typeof Cost>
+
+  export function cost(summary: RolloutAccounting.Summary): Cost {
+    const reported = Object.entries(summary.reported.currencies)
+      .toSorted(([a], [b]) => a.localeCompare(b))
+      .map(([currency, amount]) => ({ currency, amount }))
+    const coverage = summary.costCoverage
+    const estimates: z.infer<typeof Estimate>[] = []
+    const entry = (
+      basis: z.infer<typeof Estimate>["basis"],
+      metric: RolloutAccounting.Metric,
+      maximum = metric.known,
+    ) => ({ basis, currency: "USD" as const, known: metric.known, maximum, unknown: metric.unknown })
+    if (coverage) {
+      for (const basis of ["api", "unclassified"] as const) {
+        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: Cost["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),
+    }
+  }
+}

package/src/execution/preview.ts

@@ -0,0 +1,12 @@
+// 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: string): string {
+  const codes: number[] = []
+  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/src/execution/process.ts

@@ -0,0 +1,118 @@
+import type { ExecutionSchema } from "./schema"
+
+export namespace ExecutionProcess {
+  function auxiliaryKey(node: ExecutionSchema.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])
+  }
+  export function auxiliaryMembers(nodes: readonly ExecutionSchema.Node[], node: ExecutionSchema.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))
+      : []
+  }
+  export function project(nodes: readonly ExecutionSchema.Node[], mode: "process" | "records", root?: string) {
+    const byID = new Map(nodes.map((node) => [node.id, node]))
+    const children = new Map<string, ExecutionSchema.Node[]>()
+    const auxiliary = new Map<string, ExecutionSchema.Node[]>()
+    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,
+            },
+          ] as const
+        }),
+    )
+    const heads = new Map<string, ExecutionSchema.Node>()
+    const hidden = new Set<string>()
+    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: NonNullable<ExecutionSchema.Node["ancestors"]> = []
+        const seen = new Set<string>([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" as const) : ("known" as const)),
+          group: node.group ?? groups.get(node.id) ?? (node.parentID ? groups.get(node.parentID) : undefined),
+        }
+      })
+  }
+}