@tangle-network/agent-runtime 0.49.0 → 0.50.0

package/dist/{kb-gate-CsXpNRk7.d.ts → kb-gate-CHAyt4aI.d.ts}

@@ -1,5 +1,5 @@
-import { C as CoderOutput, a as CoderTask } from './coder-CVZNGbyg.js';
-import { S as SandboxClient, A as AgentRunSpec, e as LoopTraceEmitter } from './types-nBMuollC.js';
+import { C as CoderOutput, b as CoderTask } from './coder-_YCf3BAK.js';
+import { f as LoopTraceEmitter, g as LoopTraceEvent, S as SandboxClient, A as AgentRunSpec } from './types-BEQsBhOE.js';
 import { SandboxEvent, SandboxInstance } from '@tangle-network/sandbox';
 import { AgentEvalError } from '@tangle-network/agent-eval';
 import { a as UiLens, U as UiFinding } from './substrate-CUgk7F7s.js';
@@ -118,6 +118,335 @@ declare class FileDelegationStore implements DelegationStore {
     private writeSnapshot;
 }
 
+/**
+ * @experimental
+ *
+ * Compact loop-trace tee for the delegation journal.
+ *
+ * The OTEL exporter ({@link createPropagatingTraceEmitter}) is a no-op
+ * without `OTEL_EXPORTER_OTLP_ENDPOINT`, which leaves delegated work streams
+ * dark in practice. This module derives the same loop → round → branch span
+ * tree (via the shared {@link buildLoopSpanNodes} builder) into a small,
+ * JSON-safe shape persisted directly on the `DelegationRecord` — observable
+ * through `delegation_status` with no collector infrastructure. Both sinks
+ * coexist: the OTEL export path is unchanged.
+ *
+ * Payload discipline: a record's trace is hard-capped (spans + serialized
+ * bytes). Past the cap the OLDEST spans are dropped and the record carries a
+ * `traceTruncated: true` marker — truncation is never silent.
+ */
+
+/**
+ * One span of a delegation's compact trace. Flat (parent linkage by id), all
+ * values JSON-safe scalars — `FileDelegationStore` round-trips records
+ * through `JSON.stringify`. `meta` carries the span's attributes (GenAI
+ * semconv keys + `tangle.loop.*` extensions) exactly as the OTEL sink emits
+ * them, so a consumer can re-export journal traces losslessly.
+ *
+ * @experimental
+ */
+interface DelegationTraceSpan {
+    spanId: string;
+    /** Absent on the tree root. */
+    parentSpanId?: string;
+    /** `'loop'` | `'loop.round'` | `'loop.iteration'` (or a sink-specific name). */
+    name: string;
+    /** Topology level: loop root, plan round, or iteration branch. */
+    kind: 'loop' | 'round' | 'branch';
+    startMs: number;
+    endMs: number;
+    meta?: Record<string, string | number | boolean>;
+}
+/** Default cap on spans retained per delegation record. @experimental */
+declare const DELEGATION_TRACE_MAX_SPANS = 512;
+/** Default cap on the serialized trace payload per record, in bytes. @experimental */
+declare const DELEGATION_TRACE_MAX_BYTES: number;
+/** @experimental */
+interface DelegationTraceCaps {
+    /** Default {@link DELEGATION_TRACE_MAX_SPANS}. */
+    maxSpans?: number;
+    /** Default {@link DELEGATION_TRACE_MAX_BYTES}. Approximate — measured as the
+     *  sum of per-span `JSON.stringify` lengths. */
+    maxBytes?: number;
+}
+/** @experimental */
+interface CappedDelegationTrace {
+    trace: DelegationTraceSpan[];
+    /** True when oldest spans were dropped to honor the caps. */
+    truncated: boolean;
+}
+/**
+ * Derive the compact span tree for ONE loop run from its buffered
+ * `LoopTraceEvent` stream. Same reconstruction as the OTEL exporter
+ * ({@link buildLoopSpanNodes}); tolerates partial streams.
+ *
+ * @experimental
+ */
+declare function buildDelegationTraceSpans(events: ReadonlyArray<LoopTraceEvent>): DelegationTraceSpan[];
+/**
+ * Enforce the trace caps over an ordered (oldest-first) span list. Drops the
+ * OLDEST spans first and reports `truncated: true` when anything was dropped;
+ * the newest span always survives, so a non-empty input never caps to empty.
+ * Dropping a parent may orphan surviving children's `parentSpanId` references
+ * — acceptable for the flat journal shape; consumers treat unresolved parents
+ * as roots.
+ *
+ * @experimental
+ */
+declare function capDelegationTrace(spans: ReadonlyArray<DelegationTraceSpan>, caps?: DelegationTraceCaps): CappedDelegationTrace;
+/**
+ * Per-delegation trace collector. Buffers `LoopTraceEvent`s per runId
+ * (mirroring the OTEL emitter's buffering) and hands the derived compact
+ * spans to `onSpans` when a run reaches `loop.ended`. `settle()` drains runs
+ * that never ended — a hard-aborted loop still leaves its partial tree in the
+ * journal, unlike the OTEL path which drops it.
+ *
+ * @experimental
+ */
+interface DelegationTraceCollector {
+    emitter: LoopTraceEmitter;
+    /** Flush buffered events of runs that never reached `loop.ended`. */
+    settle(): void;
+}
+/** @experimental */
+declare function createDelegationTraceCollector(onSpans: (spans: DelegationTraceSpan[]) => void): DelegationTraceCollector;
+/**
+ * Fan one `LoopTraceEvent` stream into several emitters — e.g. the
+ * process-wide OTEL exporter AND the per-delegation journal collector.
+ * `undefined` entries are skipped; returns `undefined` when nothing is left
+ * so callers keep the kernel's "no emitter, no events" fast path.
+ *
+ * @experimental
+ */
+declare function composeLoopTraceEmitters(...emitters: ReadonlyArray<LoopTraceEmitter | undefined>): LoopTraceEmitter | undefined;
+
+/**
+ * OTEL span exporter — streams LoopTraceEvents to an OTLP/HTTP collector.
+ *
+ * Reads OTEL_EXPORTER_OTLP_ENDPOINT + OTEL_EXPORTER_OTLP_HEADERS from env
+ * when no explicit config is given. Keeps the runtime dep-free from
+ * @opentelemetry/sdk-trace-base — minimal OTLP/JSON serializer.
+ *
+ * The exporter accepts both raw OtelSpan objects and LoopTraceEvents
+ * (which get converted to OTLP spans automatically).
+ */
+interface OtelExportConfig {
+    /** OTLP endpoint. Reads OTEL_EXPORTER_OTLP_ENDPOINT env by default. */
+    endpoint?: string;
+    /** OTLP headers. Reads OTEL_EXPORTER_OTLP_HEADERS env by default. */
+    headers?: Record<string, string>;
+    /** Batch size before flush. Default 64. */
+    batchSize?: number;
+    /** Flush interval ms. Default 5000. */
+    flushIntervalMs?: number;
+    /** Resource attributes stamped on every export. */
+    resourceAttributes?: Record<string, string | number | boolean>;
+    /** Service name. Default 'agent-runtime'. */
+    serviceName?: string;
+}
+interface OtelExporter {
+    /** Export a span. */
+    exportSpan(span: OtelSpan): void;
+    /** Force flush pending spans. */
+    flush(): Promise<void>;
+    /** Shutdown cleanly. */
+    shutdown(): Promise<void>;
+}
+interface OtelSpan {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    kind?: number;
+    startTimeUnixNano: string;
+    endTimeUnixNano: string;
+    attributes?: OtelAttribute[];
+    status?: {
+        code: number;
+        message?: string;
+    };
+}
+interface OtelAttribute {
+    key: string;
+    value: {
+        stringValue?: string;
+        intValue?: string;
+        doubleValue?: number;
+        boolValue?: boolean;
+    };
+}
+/**
+ * Create an OTEL exporter. Returns undefined when no endpoint is configured.
+ */
+declare function createOtelExporter(config?: OtelExportConfig): OtelExporter | undefined;
+/**
+ * Convert a LoopTraceEvent into an OtelSpan for export.
+ */
+declare function loopEventToOtelSpan(event: {
+    kind: string;
+    runId: string;
+    timestamp: number;
+    payload: object;
+}, traceId: string, parentSpanId?: string): OtelSpan;
+/**
+ * Sink-neutral node in a reconstructed loop span tree. The root node's
+ * `parentSpanId` is `undefined` — sinks decide how to parent it (the OTEL
+ * mapper attaches the inherited delegation span; the delegation journal
+ * leaves it as the tree root).
+ */
+interface LoopSpanNode {
+    spanId: string;
+    parentSpanId?: string;
+    /** `'loop'` | `'loop.round'` | `'loop.iteration'`. */
+    name: string;
+    /** Topology level: loop root, plan round, or iteration branch. */
+    kind: 'loop' | 'round' | 'branch';
+    startMs: number;
+    endMs: number;
+    attrs: Record<string, string | number | boolean>;
+    /** True when the iteration carried an error — maps to OTEL status code 2. */
+    error: boolean;
+}
+/**
+ * Build a nested, real-duration OTLP span tree for ONE loop run from its full
+ * ordered `LoopTraceEvent` stream. Unlike `loopEventToOtelSpan` (one flat,
+ * zero-duration span per event), this reconstructs the topology hierarchy a
+ * GenAI trace viewer renders natively:
+ *
+ *   loop (invoke_workflow)
+ *     └─ loop.round[k] (invoke_workflow)   ← tangle.loop.move.{kind,width,rationale}
+ *          ├─ loop.iteration[i] (invoke_agent)  ← gen_ai.agent.name + usage + verdict + placement
+ *          └─ …
+ *
+ * Attributes follow the current GenAI semconv (`gen_ai.*`) where they apply and
+ * a namespaced `tangle.loop.*` / `tangle.cost.usd` extension for topology /
+ * verdict / placement / cost (not yet standardized). Pure: feed it a buffered
+ * per-runId event array (e.g. flushed on `loop.ended`) and export the result.
+ */
+declare function buildLoopOtelSpans(events: ReadonlyArray<{
+    kind: string;
+    runId: string;
+    timestamp: number;
+    payload: object;
+}>, traceId: string, rootParentSpanId?: string): OtelSpan[];
+/**
+ * Sink-neutral core behind {@link buildLoopOtelSpans}: reconstruct the
+ * loop → round → branch span tree from one run's ordered `LoopTraceEvent`
+ * stream. Consumed by the OTEL mapper above and by the MCP delegation
+ * journal's compact trace tee — one topology reconstruction, two sinks.
+ * Tolerates partial streams (a run that never reached `loop.ended` closes
+ * at the last observed event's timestamp).
+ */
+declare function buildLoopSpanNodes(events: ReadonlyArray<{
+    kind: string;
+    runId: string;
+    timestamp: number;
+    payload: object;
+}>): LoopSpanNode[];
+/** Wire version the eval-runs ingest enforces (X-Tangle-Wire-Version + body). */
+declare const INTELLIGENCE_WIRE_VERSION = "2026-05-26.v1";
+interface EvalRunGeneration {
+    /** 0-based ordinal of this generation within the run (required by ingest). */
+    index: number;
+    /** Identity of the proposed surface change (content-addressed hash). */
+    surfaceHash: string;
+    /** Arbitrary provenance for this generation (rationale, evidence, source). */
+    surface?: unknown;
+    /** Per-scenario results; empty until the generation is measured. */
+    cells?: unknown[];
+    /** Mean composite score (0 when unmeasured — pair with labels.measured). */
+    compositeMean: number;
+    costUsd: number;
+    durationMs: number;
+}
+interface EvalRunEvent {
+    runId: string;
+    runDir: string;
+    /** ISO timestamp. */
+    timestamp: string;
+    status: 'started' | 'baseline-complete' | 'generation-complete' | 'gate-decided' | 'finished' | 'errored';
+    labels?: Record<string, string>;
+    baseline?: EvalRunGeneration;
+    generations?: EvalRunGeneration[];
+    gateDecision?: 'ship' | 'hold' | 'need_more_work' | 'model_ceiling' | 'arch_ceiling';
+    holdoutLift?: number;
+    totalCostUsd: number;
+    totalDurationMs: number;
+    errorMessage?: string;
+}
+interface EvalRunsExportConfig {
+    /** Bearer key — tenant is resolved server-side from it. Reads TANGLE_API_KEY. */
+    apiKey?: string;
+    /** Intelligence base. Reads INTELLIGENCE_BASE env, else prod. */
+    base?: string;
+    /** Idempotency-Key header (e.g. the runId) — safe retries + upsert. */
+    idempotencyKey?: string;
+}
+interface EvalRunsExportResult {
+    ok: boolean;
+    status: number;
+    accepted: number;
+    rejected: Array<{
+        index: number;
+        reason: string;
+    }>;
+}
+/**
+ * Ship self-improvement eval-run events to Tangle Intelligence. Unlike the
+ * best-effort span exporter, this RESOLVES with the ingest verdict (accepted /
+ * rejected per event) so a consumer's loop can assert its provenance landed.
+ * Throws only on a missing key or network failure.
+ */
+declare function exportEvalRuns(events: EvalRunEvent[], config?: EvalRunsExportConfig): Promise<EvalRunsExportResult>;
+
+/**
+ * @experimental
+ *
+ * Trace context propagation for MCP subprocess.
+ *
+ * When the MCP server is launched as a child process by a sandbox harness,
+ * the parent passes trace context via environment variables:
+ *
+ *   TRACE_ID=<current-run-trace-id>
+ *   PARENT_SPAN_ID=<span-that-dispatched-the-delegation>
+ *
+ * The MCP server reads these at startup and uses them as the root of its
+ * internal trace tree. All spans emitted by `runLoop` invocations inside
+ * the MCP are children of the parent's delegation span.
+ *
+ * When these env vars are absent, the MCP generates a fresh trace root —
+ * the server operates standalone without trace joining.
+ */
+
+interface TraceContext {
+    /** Trace id inherited from the parent process, or a fresh one. */
+    traceId: string;
+    /** Parent span id from the delegation that launched this MCP server. */
+    parentSpanId?: string;
+}
+/**
+ * Read trace context from the process environment.
+ * Returns a context with inherited ids or a freshly generated root.
+ */
+declare function readTraceContextFromEnv(): TraceContext;
+/**
+ * Create a LoopTraceEmitter that:
+ *   1. Parents all spans under the inherited PARENT_SPAN_ID.
+ *   2. Exports spans to OTEL when OTEL_EXPORTER_OTLP_ENDPOINT is set.
+ *
+ * Returns both the emitter and the optional exporter handle for shutdown.
+ */
+declare function createPropagatingTraceEmitter(ctx: TraceContext): {
+    emitter: LoopTraceEmitter;
+    exporter: OtelExporter | undefined;
+    context: TraceContext;
+};
+/**
+ * Build env vars to pass to a child MCP subprocess so it inherits the
+ * current trace context.
+ */
+declare function traceContextToEnv(ctx: TraceContext): Record<string, string>;
+
 /**
  * @experimental
  *
@@ -230,6 +559,13 @@ interface DelegateFeedbackResult {
 /** @experimental */
 interface DelegationStatusArgs {
     taskId: string;
+    /**
+     * Return the delegation's compact loop-trace span tree alongside the
+     * status. Default false — status polls stay light; opt in when you need
+     * the topology (which iterations ran, where they were placed, what each
+     * cost) rather than just the state machine.
+     */
+    includeTrace?: boolean;
 }
 /** @experimental */
 interface DelegationProgress {
@@ -347,6 +683,14 @@ interface DelegationStatusResult {
     costUsd?: number;
     startedAt: string;
     completedAt?: string;
+    /** Compact loop-trace span tree; present only when `includeTrace: true` was passed and spans were recorded. */
+    trace?: DelegationTraceSpan[];
+    /** Present when oldest trace spans were dropped to honor the trace caps. */
+    traceTruncated?: true;
+    /** Inherited trace identity recorded at submit — join key into the caller's trace. */
+    traceId?: string;
+    /** Caller span that dispatched the delegation, when one was inherited. */
+    parentSpanId?: string;
 }
 /** @experimental */
 interface DelegationHistoryArgs {
@@ -377,6 +721,14 @@ interface DelegationHistoryEntry {
     costUsd?: number;
     startedAt: string;
     completedAt?: string;
+    /**
+     * True when the record carries a journaled loop trace. History stays
+     * light by design — fetch the spans via
+     * `delegation_status { taskId, includeTrace: true }`.
+     */
+    hasTrace: boolean;
+    /** Inherited trace identity recorded at submit — join key into the caller's trace. */
+    traceId?: string;
 }
 /** @experimental */
 interface DelegationHistoryResult {
@@ -440,6 +792,24 @@ interface DelegationRecord {
     detachedSessionRef?: string;
     /** Feedback events keyed by this delegation's taskId. */
     feedback: DelegationFeedbackSnapshot[];
+    /**
+     * Compact loop-trace span tree teed from the delegation's run, oldest
+     * spans first. Appended when a delegated loop reaches `loop.ended` and
+     * settled (partial buffers included) at the terminal transition. Capped
+     * via `capDelegationTrace` — see `traceTruncated`.
+     */
+    trace?: DelegationTraceSpan[];
+    /** Present when oldest trace spans were dropped to honor the trace caps. */
+    traceTruncated?: true;
+    /**
+     * Inherited trace identity (the queue's `traceContext` at submit time —
+     * typically `readTraceContextFromEnv()`), distinct from the span payload:
+     * a journal consumer joins records into the parent trace by these ids
+     * without parsing spans. Restored records keep their persisted identity.
+     */
+    traceId?: string;
+    /** Caller span that dispatched the delegation, when one was inherited. */
+    parentSpanId?: string;
 }
 /** @experimental */
 interface SubmitInput<Args extends AnyDelegateArgs> {
@@ -476,6 +846,16 @@ interface DelegationRunContext {
      * ref — erasing the resume key would silently make the record unresumable.
      */
     updateDetachedSessionRef(ref: string): void;
+    /**
+     * Per-delegation loop-trace sink, always provided by the queue. Events
+     * emitted here are journaled onto the record as a compact span tree
+     * (`record.trace`) when each loop run ends and at the delegation's
+     * terminal transition. Delegates forward it into their `runLoop` ctx,
+     * composed with any process-wide OTEL emitter
+     * (`composeLoopTraceEmitters`). Optional in the type so consumer-built
+     * contexts stay source-compatible.
+     */
+    traceEmitter?: LoopTraceEmitter;
 }
 /** @experimental */
 interface SubmitOutput {
@@ -554,6 +934,14 @@ interface DelegationTaskQueueOptions {
      * degrading durable mode to memory-only would lie to the caller.
      */
     onPersistError?: (error: DelegationPersistenceError) => void;
+    /**
+     * Inherited trace identity stamped on every submitted record
+     * (`traceId` / `parentSpanId`). The bin passes
+     * `readTraceContextFromEnv()` so journal consumers can join delegation
+     * records into the caller's trace. Restored records keep the identity
+     * they were persisted with.
+     */
+    traceContext?: TraceContext;
 }
 /** @experimental */
 declare class DelegationTaskQueue {
@@ -566,6 +954,7 @@ declare class DelegationTaskQueue {
     private readonly resumeDelegate?;
     private readonly maxTerminalRecords;
     private readonly onPersistError;
+    private readonly traceContext;
     private persistTail;
     private persistFailure;
     constructor(options?: DelegationTaskQueueOptions);
@@ -593,8 +982,12 @@ declare class DelegationTaskQueue {
     /**
      * Snapshot the current state of a delegation. Returns `undefined` for
      * unknown ids so callers can distinguish missing from terminal.
+     * `includeTrace` attaches the journaled loop-trace span tree — off by
+     * default so status polls stay light.
      */
-    status(taskId: string): DelegationStatusResult | undefined;
+    status(taskId: string, opts?: {
+        includeTrace?: boolean;
+    }): DelegationStatusResult | undefined;
     /**
      * Abort an in-flight delegation. Returns `false` if the task is unknown
      * or already terminal. The underlying `run` function MUST honor the
@@ -624,9 +1017,19 @@ declare class DelegationTaskQueue {
     /** Test-only — number of in-flight (non-terminal) records. */
     inflightCount(): number;
     private execute;
+    private appendTrace;
     private rehydrate;
     private startResume;
     private driveResume;
+    /**
+     * Journal the resumed segment of a detached run as one compact span. The
+     * resume driver re-attaches after a process restart, so the original
+     * process's loop events are gone — this span records the post-restart
+     * observation window (re-attach → terminal tick) under the
+     * `'detached-resume'` driver tag, keeping restored delegations observable
+     * in the journal alongside trace-carrying live runs.
+     */
+    private appendResumeSpan;
     private persist;
     private persistRemoval;
     private failPersistence;
@@ -665,11 +1068,14 @@ declare function hashIdempotencyInput(value: unknown): string;
  * SDK stays an optional peer, exactly like the executors' `SandboxClient` seam.
  *
  * Tradeoffs of detached mode (why it is opt-in, not the default): a detached
- * turn yields one terminal payload instead of a live event stream, so per-token
- * loop trace events and kernel token/cost aggregation are not produced for that
- * turn. Multi-variant fanout stays on the streaming `runLoop` path — N
- * concurrent sessions cannot be expressed as one resume key, and winner
- * selection needs every candidate.
+ * turn yields one terminal payload instead of a live event stream, so kernel
+ * token/cost aggregation is not produced for that turn. The trace sinks still
+ * observe detached work — `runDetachedTurn` synthesizes a single-iteration
+ * loop event stream (see `RunDetachedTurnOptions.traceEmitter`) so the span
+ * topology joins the inherited trace context, with cost/tokens reported as 0
+ * under the `'detached-turn'` driver tag. Multi-variant fanout stays on the
+ * streaming `runLoop` path — N concurrent sessions cannot be expressed as one
+ * resume key, and winner selection needs every candidate.
  */
 
 /**
@@ -768,6 +1174,18 @@ interface RunDetachedTurnOptions {
     tickIntervalMs?: number;
     /** Wall-clock cap forwarded to `driveTurn` — the SDK cancels and fails a session past it. */
     wallCapMs?: number;
+    /**
+     * Loop-trace sink. When set, the detached turn synthesizes a
+     * single-iteration loop span tree (`runId` = `sessionId`, driver
+     * `'detached-turn'`) so trace-context inheritance survives the detached
+     * path — the same events the streaming `runLoop` path would emit, minus
+     * per-token telemetry: `driveTurn` yields one terminal payload, so token
+     * and cost figures are structurally unavailable and reported as 0 under
+     * this driver tag.
+     */
+    traceEmitter?: LoopTraceEmitter;
+    /** Physical placement stamped on the synthesized dispatch event. Default `'sibling'`. */
+    placement?: 'sibling' | 'fleet';
 }
 /**
  * Dispatch one detached turn and advance it to a terminal state with
@@ -936,6 +1354,13 @@ interface DelegateRunCtx {
     detachedSessionRef?: string;
     /** Rebind the record's resume key (e.g. once the sandbox id is known). */
     updateDetachedSessionRef?(ref: string): void;
+    /**
+     * Per-delegation trace sink supplied by the queue — loop events emitted
+     * here land on the delegation record as a compact span tree. Delegates
+     * compose it with their configured OTEL emitter so both sinks observe
+     * the same stream.
+     */
+    traceEmitter?: LoopTraceEmitter;
 }
 /** @experimental */
 type CoderDelegate = (args: DelegateCodeArgs, ctx: DelegateRunCtx) => Promise<CoderOutput>;
@@ -1020,7 +1445,8 @@ interface CreateDefaultCoderDelegateOptions {
      * are a cheap no-op when it isn't. Configurable by construction.
      *
      * Detached single-variant turns (taken when `ctx.detachedSessionRef` is set)
-     * bypass `runLoop` and therefore emit no loop trace events for that turn.
+     * bypass `runLoop`; `runDetachedTurn` synthesizes a single-iteration loop
+     * event stream for them so this emitter observes detached work too.
      */
     traceEmitter?: LoopTraceEmitter;
     /** Tick cadence (ms) for the detached single-variant path. Default 5000. */
@@ -1142,4 +1568,4 @@ interface CreateKbGateOptions {
  */
 declare function createKbGate(options?: CreateKbGateOptions): (candidate: FactCandidate) => Promise<KbGateResult>;
 
-export { type FeedbackRating as $, type DelegationError as A, type DelegationHistoryEntry as B, type CoderReviewer as C, type DelegateCodeArgs as D, DelegationPersistenceError as E, type FactCandidate as F, type DelegationProfile as G, type DelegationProgress as H, type DelegationRecord as I, type DelegationResultPayload as J, type DelegationResumeContext as K, type DelegationResumeDriver as L, type DelegationResumeTick as M, type DelegationRunContext as N, DelegationStateCorruptError as O, type DelegationStatus as P, type DelegationStore as Q, type ResearcherDelegate as R, type DelegationTaskQueueOptions as S, type DetachedSessionRefParts as T, type UiAuditorDelegate as U, type DetachedTurn as V, type DriveTurnCapableBox as W, type DriveTurnResumeDriverOptions as X, type DriveTurnTick as Y, type FactJudge as Z, type FactJudgeVerdict as _, type CoderWinnerSelection as a, type FeedbackRefersTo as a0, FileDelegationStore as a1, type FileDelegationStoreOptions as a2, type FleetWorkspaceExecutorOptions as a3, InMemoryDelegationStore as a4, type KbGateResult as a5, type ResearchOutputShape as a6, type RunDetachedTurnOptions as a7, type SettleDetachedCoderTurnOptions as a8, type SiblingSandboxExecutorOptions as a9, type SubmitInput as aa, type SubmitOutput as ab, type UiAuditorDelegationOutput as ac, coderTaskFromArgs as ad, createDefaultCoderDelegate as ae, createDriveTurnResumeDriver as af, createFleetWorkspaceExecutor as ag, createKbGate as ah, createSiblingSandboxExecutor as ai, detachedTurnEvents as aj, formatDetachedSessionRef as ak, hashIdempotencyInput as al, parseDetachedSessionRef as am, runDetachedTurn as an, settleDetachedCoderTurn as ao, type CreateKbGateOptions as b, type FleetHandle as c, type DelegationExecutor as d, type DelegateFeedbackArgs as e, type DelegationFeedbackSnapshot as f, DelegationTaskQueue as g, type CoderDelegate as h, type DelegateCodeResult as i, type DelegateFeedbackResult as j, type ResearchSource as k, type DelegateResearchArgs as l, type DelegateResearchResult as m, type DelegateUiAuditArgs as n, type DelegateUiAuditResult as o, type DelegationHistoryResult as p, type DelegationHistoryArgs as q, type DelegationStatusResult as r, type DelegationStatusArgs as s, type CoderReview as t, type CreateDefaultCoderDelegateOptions as u, type DelegateCodeConfig as v, type DelegateResearchConfig as w, type DelegateRunCtx as x, type DelegateUiAuditConfig as y, type DelegateUiAuditRoute as z };
+export { type DetachedSessionRefParts as $, type DelegateRunCtx as A, type DelegateUiAuditConfig as B, type CoderReviewer as C, type DelegateCodeArgs as D, type DelegateUiAuditRoute as E, type FactCandidate as F, type DelegationError as G, type DelegationHistoryEntry as H, DelegationPersistenceError as I, type DelegationProfile as J, type DelegationProgress as K, type DelegationRecord as L, type DelegationResultPayload as M, type DelegationResumeContext as N, type DelegationResumeDriver as O, type DelegationResumeTick as P, type DelegationRunContext as Q, type ResearcherDelegate as R, DelegationStateCorruptError as S, type TraceContext as T, type UiAuditorDelegate as U, type DelegationStatus as V, type DelegationStore as W, type DelegationTaskQueueOptions as X, type DelegationTraceCaps as Y, type DelegationTraceCollector as Z, type DelegationTraceSpan as _, type CoderWinnerSelection as a, type DetachedTurn as a0, type DriveTurnCapableBox as a1, type DriveTurnResumeDriverOptions as a2, type DriveTurnTick as a3, type FactJudge as a4, type FactJudgeVerdict as a5, type FeedbackRating as a6, type FeedbackRefersTo as a7, FileDelegationStore as a8, type FileDelegationStoreOptions as a9, runDetachedTurn as aA, settleDetachedCoderTurn as aB, traceContextToEnv as aC, type EvalRunEvent as aD, type EvalRunGeneration as aE, type EvalRunsExportConfig as aF, type EvalRunsExportResult as aG, INTELLIGENCE_WIRE_VERSION as aH, type LoopSpanNode as aI, type OtelAttribute as aJ, type OtelExportConfig as aK, type OtelExporter as aL, type OtelSpan as aM, buildLoopOtelSpans as aN, buildLoopSpanNodes as aO, createOtelExporter as aP, exportEvalRuns as aQ, loopEventToOtelSpan as aR, type FleetWorkspaceExecutorOptions as aa, InMemoryDelegationStore as ab, type KbGateResult as ac, type ResearchOutputShape as ad, type RunDetachedTurnOptions as ae, type SettleDetachedCoderTurnOptions as af, type SiblingSandboxExecutorOptions as ag, type SubmitInput as ah, type SubmitOutput as ai, type UiAuditorDelegationOutput as aj, buildDelegationTraceSpans as ak, capDelegationTrace as al, coderTaskFromArgs as am, composeLoopTraceEmitters as an, createDefaultCoderDelegate as ao, createDelegationTraceCollector as ap, createDriveTurnResumeDriver as aq, createFleetWorkspaceExecutor as ar, createKbGate as as, createPropagatingTraceEmitter as at, createSiblingSandboxExecutor as au, detachedTurnEvents as av, formatDetachedSessionRef as aw, hashIdempotencyInput as ax, parseDetachedSessionRef as ay, readTraceContextFromEnv as az, type CreateKbGateOptions as b, type FleetHandle as c, type DelegationExecutor as d, type DelegateFeedbackArgs as e, type DelegationFeedbackSnapshot as f, DelegationTaskQueue as g, type CoderDelegate as h, type DelegateCodeResult as i, type DelegateFeedbackResult as j, type ResearchSource as k, type DelegateResearchArgs as l, type DelegateResearchResult as m, type DelegateUiAuditArgs as n, type DelegateUiAuditResult as o, type DelegationHistoryResult as p, type DelegationHistoryArgs as q, type DelegationStatusResult as r, type DelegationStatusArgs as s, type CappedDelegationTrace as t, type CoderReview as u, type CreateDefaultCoderDelegateOptions as v, DELEGATION_TRACE_MAX_BYTES as w, DELEGATION_TRACE_MAX_SPANS as x, type DelegateCodeConfig as y, type DelegateResearchConfig as z };

package/dist/{loop-runner-bin-Cgn0A-NW.d.ts → loop-runner-bin-DFUNgpeK.d.ts}

@@ -1,10 +1,10 @@
 import { Scenario } from '@tangle-network/agent-eval/campaign';
 import { SelfImproveOptions, SelfImproveResult } from '@tangle-network/agent-eval/contract';
 import { R as RunAnalystLoopOpts, a as RunAnalystLoopResult } from './types-p8dWBIXL.js';
-import { D as DelegateCodeArgs, C as CoderReviewer, a as CoderWinnerSelection, F as FactCandidate, b as CreateKbGateOptions } from './kb-gate-CsXpNRk7.js';
-import { C as CoderOutput } from './coder-CVZNGbyg.js';
-import { S as SandboxClient, O as OutputAdapter, V as Validator, A as AgentRunSpec, b as LoopResult } from './types-nBMuollC.js';
-import { T as TopologyPlanner, C as CreateDriverOptions, D as DriverDecision } from './driver-DYU2sgHr.js';
+import { D as DelegateCodeArgs, C as CoderReviewer, a as CoderWinnerSelection, F as FactCandidate, b as CreateKbGateOptions } from './kb-gate-CHAyt4aI.js';
+import { C as CoderOutput } from './coder-_YCf3BAK.js';
+import { S as SandboxClient, O as OutputAdapter, V as Validator, A as AgentRunSpec, b as LoopResult } from './types-BEQsBhOE.js';
+import { T as TopologyPlanner, C as CreateDriverOptions, D as DriverDecision } from './driver-DLI1io57.js';
 
 /**
  * @experimental

package/dist/loop-runner-bin.d.ts

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
-export { L as LoopRunnerCliArgs, f as LoopRunnerCliResult, p as parseLoopRunnerArgv, o as runLoopRunnerCli } from './loop-runner-bin-Cgn0A-NW.js';
+export { L as LoopRunnerCliArgs, f as LoopRunnerCliResult, p as parseLoopRunnerArgv, o as runLoopRunnerCli } from './loop-runner-bin-DFUNgpeK.js';
 import '@tangle-network/agent-eval/campaign';
 import '@tangle-network/agent-eval/contract';
 import './types-p8dWBIXL.js';
 import '@tangle-network/agent-eval';
-import './kb-gate-CsXpNRk7.js';
-import './coder-CVZNGbyg.js';
+import './kb-gate-CHAyt4aI.js';
+import './coder-_YCf3BAK.js';
 import '@tangle-network/sandbox';
-import './types-nBMuollC.js';
+import './types-BEQsBhOE.js';
 import './runtime-hooks-C7JwKb9E.js';
 import './substrate-CUgk7F7s.js';
-import './driver-DYU2sgHr.js';
+import './driver-DLI1io57.js';

package/dist/loop-runner-bin.js

@@ -2,12 +2,12 @@
 import {
   parseLoopRunnerArgv,
   runLoopRunnerCli
-} from "./chunk-U2VEWKKK.js";
+} from "./chunk-BKAIVNFA.js";
 import "./chunk-FNMGYYSS.js";
-import "./chunk-GHX7XOJ2.js";
+import "./chunk-OM3YNZIW.js";
 import "./chunk-KADIJAD4.js";
 import "./chunk-HNUXAZIJ.js";
-import "./chunk-PXUTIMGJ.js";
+import "./chunk-CM2IK7VS.js";
 import "./chunk-GSUO5QS6.js";
 import "./chunk-DGUM43GV.js";
 export {

package/dist/loops.d.ts

@@ -1,9 +1,9 @@
 export { AgentProfile, CreateSandboxOptions, SandboxEvent, SandboxInstance } from '@tangle-network/sandbox';
-export { AgenticOptions, AgenticRunResult, AgenticSurface, AgenticTask, AgenticTool, AnytimeReport, AnytimeStrategySummary, AnytimeTaskCurve, ArtifactHandle, AssertTraceDerivedFindings, AuditIntentInput, AuditIntentOptions, AuthorStrategyOptions, AuthoredStrategy, BenchmarkCell, BenchmarkConfig, BenchmarkLift, BenchmarkReport, BenchmarkStrategySummary, BenchmarkTaskRow, BridgeSeam, BudgetPool, BudgetReadout, ChampionPick, ChampionPolicy, CheckpointCapableBox, CliSeam, CombinatorShape, Corpus, CorpusFilter, CorpusRecord, CreateScopeAnalystOptions, CriuCapableClient, DefinePersona, DefinePersonaInput, Deliverable, Environment, EqualKArm, EqualKOnCost, EqualKOnCostOptions, EqualKVerdict, EvolutionArchiveNode, EvolutionAuthor, EvolutionBandInfo, EvolutionCandidate, EvolutionGeneration, EvolutionReport, ExecutorConfig, Fanout, FanoutOptions, FanoutSynthesis, FileCorpus, FileResultBlobStore, FileSpawnJournal, FlatWidenGate, ForkCapableBox, GitWorkspaceOptions, HarvestCorpusOptions, HarvestFailure, HarvestReport, InMemoryCorpus, InMemoryResultBlobStore, InMemorySpawnJournal, IntentAudit, LoopDispatchOptions, LoopOptionsForDispatch, LoopShape, LoopUntil, LoopUntilSpec, LoopUntilState, McpEndpoint, McpEnvironmentOptions, Observation, ObserveInput, ObserveOptions, OpenSandboxRunOptions, Outcome, Panel, PanelJudge, PanelSpec, PanelVerdict, Persona, PersonaContext, PersonaExecutors, Pipeline, PipelineStage, PromotionGateOptions, PromotionVerdict, RenderCorpusToInstructions, RenderCorpusToInstructionsOptions, ReservationTicket, RouterSeam, RouterToolsSeam, RunAgenticOptions, RunPersonified, RunPersonifiedOptions, SandboxCapabilities, SandboxLineage, SandboxLineageHandle, SandboxRun, SandboxSeam, ScopeAnalyst, ScopeAnalyzeInput, ScopeWidenGate, SessionCapableBox, ShapeBudget, ShapeContext, ShapeRegistry, Shell, ShotPersona, ShotSpec, SteerContext, Strategy, StrategyCtx, StrategyEvolutionConfig, StrategyResult, SurfaceScore, ToolSpec, TrajectoryNode, TrajectoryReport, TrajectoryReportFn, TrajectoryReportOptions, TurnResult, UsageSink, VerifierEnvironmentOptions, Verify, VerifySpec, WaterfallCollector, WaterfallReport, WaterfallSpan, Widen, WidenDecision, WidenLineage, WidenSpec, Workspace, WorkspaceCommit, acquireSandbox, adaptiveRefine, anytimeReport, assertStrategyContract, assertTraceDerivedFindings, auditIntent, authorStrategy, breadthDriver, buildSteerContext, builtinShapes, contentAddress, createBudgetPool, createExecutor, createExecutorRegistry, createMcpEnvironment, createRootHandle, createSandboxLineage, createScope, createScopeAnalyst, createShapeRegistry, createSupervisor, createVerifierEnvironment, createWaterfallCollector, defaultAnalystInstruction, defaultAuditorInstruction, definePersona, defineStrategy, depthDriver, discriminatingMeans, equalKOnCost, extractLlmCallEvent, fanout, flatWidenGate, gitWorkspace, harvestCorpus, inlineSandboxClient, jjWorkspace, localShell, loopDispatch, loopUntil, mapSandboxEvent, materializeTreeView, observe, openSandboxRun, panel, pickChampion, pipeline, printBenchmarkReport, probeSandboxCapabilities, promotionGate, refine, registerShape, renderAnytimeTable, renderCorpusToInstructions, renderReport, replaySpawnTree, reportLoopUsage, runAgentic, runBenchmark, runPersonified, runStrategyEvolution, sample, sampleThenRefine, selectChampion, settledToIteration, spendFromUsageEvents, strategyAuthorContract, trajectoryReport, verify, widen } from './runtime.js';
-export { A as AnalyzeInput, a as CompletionAnalyst, b as CompletionEvidence, c as CompletionPolicy, d as CompletionVerdict, C as CreateDriverOptions, D as DriverDecision, P as PlannerContext, e as TopologyMove, T as TopologyPlanner, f as completionAuthorizes, g as createDriver, h as deterministicCompletion, r as renderAnalyses, s as sentinelCompletion, i as stopSentinel } from './driver-DYU2sgHr.js';
-export { R as RunLoopOptions, c as createSandboxForSpec, d as defaultSelectWinner, r as runLoop } from './run-loop-DvD4aGiE.js';
-export { A as Agent, d as AgentSpec, B as Budget, j as Executor, k as ExecutorContext, h as ExecutorFactory, E as ExecutorRegistry, l as ExecutorResult, H as Handle, N as NodeId, m as NodeSnapshot, n as NodeStatus, o as Restart, R as ResultBlobStore, e as RootHandle, p as RootSignal, q as Runtime, S as Scope, c as Settled, b as SpawnEvent, a as SpawnJournal, r as SpawnOpts, g as Spend, f as SupervisedResult, i as Supervisor, s as SupervisorOpts, T as TreeView, U as UsageEvent, W as WidenGate } from './types-BpDfCPUp.js';
-export { A as AgentRunSpec, D as Driver, E as ExecCtx, I as Iteration, C as LoopDecisionPayload, F as LoopEndedPayload, G as LoopIterationDispatchPayload, H as LoopIterationEndedPayload, J as LoopIterationStartedPayload, a as LoopLineageOptions, M as LoopPlanDescription, N as LoopPlanPayload, b as LoopResult, f as LoopSandboxPlacement, P as LoopStartedPayload, Q as LoopTeardownFailedPayload, c as LoopTokenUsage, e as LoopTraceEmitter, T as LoopTraceEvent, L as LoopWinner, O as OutputAdapter, S as SandboxClient, U as ValidationCtx, V as Validator } from './types-nBMuollC.js';
+export { AgenticOptions, AgenticRunResult, AgenticSurface, AgenticTask, AgenticTool, AnytimeReport, AnytimeStrategySummary, AnytimeTaskCurve, ArtifactHandle, AssertTraceDerivedFindings, AuditIntentInput, AuditIntentOptions, AuthorStrategyOptions, AuthoredStrategy, BenchmarkCell, BenchmarkConfig, BenchmarkLift, BenchmarkReport, BenchmarkStrategySummary, BenchmarkTaskRow, BridgeSeam, BudgetPool, BudgetReadout, ChampionPick, ChampionPolicy, CheckpointCapableBox, CliSeam, CombinatorShape, Corpus, CorpusFilter, CorpusRecord, CreateScopeAnalystOptions, CriuCapableClient, DefinePersona, DefinePersonaInput, Deliverable, Environment, EqualKArm, EqualKOnCost, EqualKOnCostOptions, EqualKVerdict, EvolutionArchiveNode, EvolutionAuthor, EvolutionBandInfo, EvolutionCandidate, EvolutionGeneration, EvolutionReport, ExecutorConfig, Fanout, FanoutOptions, FanoutSynthesis, FileCorpus, FileResultBlobStore, FileSpawnJournal, FlatWidenGate, ForkCapableBox, GitWorkspaceOptions, HarvestCorpusOptions, HarvestFailure, HarvestReport, InMemoryCorpus, InMemoryResultBlobStore, InMemorySpawnJournal, IntentAudit, LoopDispatchOptions, LoopOptionsForDispatch, LoopShape, LoopUntil, LoopUntilSpec, LoopUntilState, McpEndpoint, McpEnvironmentOptions, Observation, ObserveInput, ObserveOptions, OpenSandboxRunOptions, Outcome, Panel, PanelJudge, PanelSpec, PanelVerdict, Persona, PersonaContext, PersonaExecutors, Pipeline, PipelineStage, PromotionGateOptions, PromotionVerdict, RenderCorpusToInstructions, RenderCorpusToInstructionsOptions, ReservationTicket, RouterChatResult, RouterChatToolsResult, RouterConfig, RouterSeam, RouterToolCall, RouterToolLoopResult, RouterToolsSeam, RunAgenticOptions, RunPersonified, RunPersonifiedOptions, SandboxCapabilities, SandboxLineage, SandboxLineageHandle, SandboxRun, SandboxSeam, ScopeAnalyst, ScopeAnalyzeInput, ScopeWidenGate, SessionCapableBox, ShapeBudget, ShapeContext, ShapeRegistry, Shell, ShotPersona, ShotSpec, SteerContext, Strategy, StrategyCtx, StrategyEvolutionConfig, StrategyResult, SurfaceScore, ToolSpec, TrajectoryNode, TrajectoryReport, TrajectoryReportFn, TrajectoryReportOptions, TurnResult, UsageSink, VerifierEnvironmentOptions, Verify, VerifySpec, WaterfallCollector, WaterfallReport, WaterfallSpan, Widen, WidenDecision, WidenLineage, WidenSpec, Workspace, WorkspaceCommit, acquireSandbox, adaptiveRefine, anytimeReport, assertStrategyContract, assertTraceDerivedFindings, auditIntent, authorStrategy, breadthDriver, buildSteerContext, builtinShapes, contentAddress, createBudgetPool, createExecutor, createExecutorRegistry, createMcpEnvironment, createRootHandle, createSandboxLineage, createScope, createScopeAnalyst, createShapeRegistry, createSupervisor, createVerifierEnvironment, createWaterfallCollector, defaultAnalystInstruction, defaultAuditorInstruction, definePersona, defineStrategy, depthDriver, discriminatingMeans, equalKOnCost, extractLlmCallEvent, fanout, flatWidenGate, gitWorkspace, harvestCorpus, inlineSandboxClient, jjWorkspace, localShell, loopDispatch, loopUntil, mapSandboxEvent, materializeTreeView, observe, openSandboxRun, panel, pickChampion, pipeline, printBenchmarkReport, probeSandboxCapabilities, promotionGate, refine, registerShape, renderAnytimeTable, renderCorpusToInstructions, renderReport, replaySpawnTree, reportLoopUsage, routerChatWithTools, routerChatWithUsage, routerToolLoop, runAgentic, runBenchmark, runPersonified, runStrategyEvolution, sample, sampleThenRefine, selectChampion, settledToIteration, spendFromUsageEvents, strategyAuthorContract, trajectoryReport, verify, widen } from './runtime.js';
+export { A as AnalyzeInput, a as CompletionAnalyst, b as CompletionEvidence, c as CompletionPolicy, d as CompletionVerdict, C as CreateDriverOptions, D as DriverDecision, P as PlannerContext, e as TopologyMove, T as TopologyPlanner, f as completionAuthorizes, g as createDriver, h as deterministicCompletion, r as renderAnalyses, s as sentinelCompletion, i as stopSentinel } from './driver-DLI1io57.js';
+export { R as RunLoopOptions, c as createSandboxForSpec, d as defaultSelectWinner, r as runLoop } from './run-loop-BIineL1T.js';
+export { A as Agent, d as AgentSpec, B as Budget, j as Executor, k as ExecutorContext, h as ExecutorFactory, E as ExecutorRegistry, l as ExecutorResult, H as Handle, N as NodeId, m as NodeSnapshot, n as NodeStatus, o as Restart, R as ResultBlobStore, e as RootHandle, p as RootSignal, q as Runtime, S as Scope, c as Settled, b as SpawnEvent, a as SpawnJournal, r as SpawnOpts, g as Spend, f as SupervisedResult, i as Supervisor, s as SupervisorOpts, T as TreeView, U as UsageEvent, W as WidenGate } from './types-5MGt5KTY.js';
+export { A as AgentRunSpec, D as Driver, E as ExecCtx, I as Iteration, F as LoopDecisionPayload, G as LoopEndedPayload, H as LoopIterationDispatchPayload, J as LoopIterationEndedPayload, M as LoopIterationStartedPayload, a as LoopLineageOptions, N as LoopPlanDescription, P as LoopPlanPayload, b as LoopResult, e as LoopSandboxPlacement, Q as LoopStartedPayload, T as LoopTeardownFailedPayload, d as LoopTokenUsage, f as LoopTraceEmitter, g as LoopTraceEvent, L as LoopWinner, O as OutputAdapter, S as SandboxClient, U as ValidationCtx, V as Validator } from './types-BEQsBhOE.js';
 export { DefaultVerdict } from '@tangle-network/agent-eval';
 import './runtime-hooks-C7JwKb9E.js';
 import '@tangle-network/agent-eval/campaign';