@tangle-network/agent-runtime 0.90.1 → 0.92.0

package/dist/intelligence.js

@@ -1,10 +1,37 @@
+import {
+  improve
+} from "./chunk-RSWM2ZKM.js";
+import {
+  canonicalCandidateBytes,
+  canonicalCandidateDigest,
+  canonicalCandidateDocument,
+  executePreparedAgentCandidate,
+  immutableCandidateValue,
+  omitTopLevelDigest,
+  prepareAgentCandidateExecution,
+  verifyAgentCandidateBundle
+} from "./chunk-A62TP7SK.js";
+import "./chunk-3BE7KTMU.js";
+import {
+  runAnalystLoop
+} from "./chunk-ZQZX77MM.js";
+import "./chunk-FRBHUNQ7.js";
 import {
   buildLoopOtelSpans,
+  buildRuntimeEventOtelSpans,
   createOtelExporter,
   flatOtelSpan
-} from "./chunk-IVGYLCFH.js";
+} from "./chunk-APVPRF4Y.js";
+import "./chunk-3D2RHC4K.js";
+import "./chunk-3MDZX7YU.js";
+import "./chunk-FVJ7M3DA.js";
+import "./chunk-CMYMTRGA.js";
+import "./chunk-YEJR7IXO.js";
 import "./chunk-DGUM43GV.js";
 
+// src/intelligence/index.ts
+import { contentHash } from "@tangle-network/agent-eval";
+
 // src/intelligence/delivery.ts
 var defaultPlaneBaseUrl = "https://intelligence.tangle.tools";
 var defaultRefreshMs = 3e5;
@@ -385,6 +412,311 @@ function isJsonSchema(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 
+// src/intelligence/improvement-cycle.ts
+import { assertNoJudgeVerdict } from "@tangle-network/agent-eval/analyst";
+import { agentCandidateBundleSchema as agentCandidateBundleSchema2, agentProfileSchema } from "@tangle-network/agent-interface";
+
+// src/candidate-execution/bundle.ts
+import { agentCandidateBundleSchema } from "@tangle-network/agent-interface";
+function sealAgentCandidateBundle(input) {
+  const digest = canonicalCandidateDigest(input);
+  const parsed = agentCandidateBundleSchema.parse({ ...input, digest });
+  const parsedDigest = canonicalCandidateDigest(omitTopLevelDigest(parsed));
+  if (parsedDigest !== digest) {
+    throw new Error("candidate bundle changed while validating its canonical wire shape");
+  }
+  return immutableCandidateValue(parsed);
+}
+
+// src/intelligence/improvement-cycle.ts
+async function proposeAgentImprovement(options) {
+  if (options.improvement.skills?.writeBack) {
+    throw new Error("proposeAgentImprovement cannot write a skill before human approval");
+  }
+  const analysis = await runAnalystLoop({
+    ...options.analysis,
+    runId: options.runId
+  });
+  const findings = assertNoJudgeVerdict(
+    analysis.analystResult.findings,
+    "proposeAgentImprovement findings"
+  );
+  const improvement = await improve(options.profile, [...findings], options.improvement);
+  const candidateBundle = improvement.shipped && options.buildCandidate ? sealAgentCandidateBundle(await options.buildCandidate({ analysis, improvement })) : void 0;
+  if (candidateBundle) assertCandidateProfileBinding(improvement.profile, candidateBundle.profile);
+  const surface = options.improvement.surface ?? "prompt";
+  const evaluation = canonicalJsonValue(improvementEvaluation(improvement.raw));
+  const proposalFindings = canonicalJsonValue([...findings]);
+  const withoutDigest = {
+    schemaVersion: 1,
+    kind: "agent-improvement-proposal",
+    runId: options.runId,
+    surface,
+    proposedAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+    baselineProfileHash: canonicalCandidateDigest(options.profile),
+    candidateProfile: improvement.profile,
+    candidateProfileHash: canonicalCandidateDigest(improvement.profile),
+    findings: proposalFindings,
+    evaluation,
+    ...candidateBundle ? { candidateBundle } : {}
+  };
+  const proposal = canonicalCandidateDocument(withoutDigest).value;
+  return { analysis, improvement, proposal };
+}
+function reviewAgentImprovementProposal(inputProposal, input) {
+  const proposal = verifyAgentImprovementProposal(inputProposal);
+  if (!input.reviewedBy.trim()) throw new Error("candidate review requires reviewedBy");
+  if (!input.reason.trim()) throw new Error("candidate review requires a reason");
+  if (input.decision === "approve") {
+    if (proposal.evaluation.gateDecision !== "ship") {
+      throw new Error("candidate cannot be approved without a passing measured comparison");
+    }
+    if (!proposal.candidateBundle) {
+      throw new Error("candidate cannot be approved until an executable bundle is sealed");
+    }
+  }
+  const withoutDigest = {
+    schemaVersion: 1,
+    kind: "agent-improvement-review",
+    proposalDigest: proposal.digest,
+    ...proposal.candidateBundle ? { candidateBundleDigest: proposal.candidateBundle.digest } : {},
+    decision: input.decision,
+    reviewedBy: input.reviewedBy,
+    reviewedAt: (input.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+    reason: input.reason,
+    ...input.feedback === void 0 ? {} : { feedback: input.feedback }
+  };
+  return canonicalCandidateDocument(withoutDigest).value;
+}
+async function executeApprovedAgentCandidate(options) {
+  const proposal = verifyAgentImprovementProposal(options.proposal);
+  const review = verifyAgentImprovementReview(options.review);
+  if (review.decision !== "approve") throw new Error("candidate review is not an approval");
+  if (review.proposalDigest !== proposal.digest) {
+    throw new Error("candidate approval does not match the proposed improvement");
+  }
+  const bundle = proposal.candidateBundle;
+  if (!bundle) throw new Error("approved proposal does not contain an executable candidate bundle");
+  if (review.candidateBundleDigest !== bundle.digest) {
+    throw new Error("candidate approval does not match the executable bundle");
+  }
+  if (!await options.authorizeReview(review, proposal)) {
+    throw new Error("candidate approval was not authorized by the configured authority");
+  }
+  const verified = await verifyAgentCandidateBundle(bundle, options.ports);
+  const prepared = await prepareAgentCandidateExecution(
+    verified,
+    options.task,
+    options.ports,
+    options.preparation
+  );
+  const finalization = await executePreparedAgentCandidate(prepared, options.execution);
+  return {
+    finalization,
+    evidence: {
+      proposalDigest: proposal.digest,
+      reviewDigest: review.digest,
+      bundleDigest: bundle.digest,
+      executionId: prepared.executionId,
+      executionPlanDigest: prepared.executionPlan.value.digest,
+      materializationReceiptDigest: prepared.materializationReceipt.digest,
+      succeeded: finalization.succeeded,
+      ...finalization.succeeded ? { runReceiptDigest: finalization.receipt.digest } : {}
+    }
+  };
+}
+function verifyAgentImprovementProposal(input) {
+  if (!isRecord(input) || input.kind !== "agent-improvement-proposal" || input.schemaVersion !== 1) {
+    throw new Error("invalid agent improvement proposal");
+  }
+  const proposal = input;
+  const parsedProfile = parseExactAgentProfile(proposal.candidateProfile);
+  if (proposal.candidateProfileHash !== canonicalCandidateDigest(parsedProfile)) {
+    throw new Error("proposal candidateProfileHash does not match candidateProfile");
+  }
+  if (!Array.isArray(proposal.findings)) throw new Error("proposal findings must be an array");
+  if (!isSha256Digest(proposal.digest)) throw new Error("proposal digest is invalid");
+  if (proposal.candidateBundle) {
+    const parsedBundle = agentCandidateBundleSchema2.parse(proposal.candidateBundle);
+    const sealed = sealAgentCandidateBundle(omitTopLevelDigest(parsedBundle));
+    if (sealed.digest !== parsedBundle.digest)
+      throw new Error("proposal candidate bundle digest is invalid");
+    assertCandidateProfileBinding(parsedProfile, sealed.profile);
+  }
+  const actual = canonicalCandidateDigest(omitTopLevelDigest(proposal));
+  if (actual !== proposal.digest)
+    throw new Error("agent improvement proposal digest does not match");
+  return immutableCandidateValue(proposal);
+}
+function parseExactAgentProfile(input) {
+  const parsed = agentProfileSchema.parse(input);
+  if (!Buffer.from(canonicalCandidateBytes(input)).equals(
+    Buffer.from(canonicalCandidateBytes(parsed))
+  )) {
+    throw new Error("proposal candidate profile contains fields unsupported by sealed candidates");
+  }
+  return parsed;
+}
+function assertCandidateProfileBinding(measuredInput, bundled) {
+  const measured = parseExactAgentProfile(measuredInput);
+  if (measured.connections || measured.metadata || measured.extensions) {
+    throw new Error("proposal candidate profile contains fields unsupported by sealed candidates");
+  }
+  const normalized = candidateProfileAsAgentProfile(bundled);
+  if (canonicalCandidateDigest(measured) !== canonicalCandidateDigest(normalized)) {
+    throw new Error("proposal candidateProfile does not match candidateBundle.profile");
+  }
+}
+function candidateProfileAsAgentProfile(candidate) {
+  const value = candidate;
+  const output = {};
+  for (const key of [
+    "name",
+    "description",
+    "version",
+    "tags",
+    "prompt",
+    "harness",
+    "permissions",
+    "tools",
+    "confidential"
+  ]) {
+    if (value[key] !== void 0) output[key] = value[key];
+  }
+  if (candidate.model) output.model = { ...candidate.model };
+  if (candidate.mcp) {
+    output.mcp = Object.fromEntries(
+      Object.entries(candidate.mcp).map(([name, server]) => [
+        name,
+        {
+          ...server,
+          ...server.args ? { args: server.args.map(publicValue) } : {},
+          ...server.env ? { env: mapPublicValues(server.env) } : {}
+        }
+      ])
+    );
+  }
+  if (candidate.subagents) output.subagents = mapRecord(candidate.subagents);
+  if (candidate.modes) output.modes = mapRecord(candidate.modes);
+  if (candidate.hooks) {
+    output.hooks = Object.fromEntries(
+      Object.entries(candidate.hooks).map(([event, hooks]) => [
+        event,
+        hooks.map((hook) => ({
+          ...hook,
+          command: [hook.executable, ...(hook.args ?? []).map(publicValue)].map(shellQuote).join(" "),
+          ...hook.env ? { env: mapPublicValues(hook.env) } : {}
+        }))
+      ])
+    );
+  }
+  if (candidate.resources) {
+    if (candidate.resources.failOnError !== true) {
+      throw new Error("proposal candidate profile contains fields unsupported by sealed candidates");
+    }
+    output.resources = {
+      failOnError: true,
+      ...candidate.resources.files ? {
+        files: candidate.resources.files.map((file) => ({
+          ...file,
+          resource: publicResource(file.resource)
+        }))
+      } : {},
+      ...candidate.resources.tools ? { tools: candidate.resources.tools.map(publicResource) } : {},
+      ...candidate.resources.skills ? { skills: candidate.resources.skills.map(publicResource) } : {},
+      ...candidate.resources.agents ? { agents: candidate.resources.agents.map(publicResource) } : {},
+      ...candidate.resources.commands ? { commands: candidate.resources.commands.map(publicResource) } : {},
+      ...candidate.resources.instructions !== void 0 ? {
+        instructions: typeof candidate.resources.instructions === "string" ? candidate.resources.instructions : publicResource(candidate.resources.instructions)
+      } : {}
+    };
+  }
+  return output;
+}
+function publicResource(resource) {
+  if (resource.kind === "inline") {
+    return { kind: "inline", name: resource.name, content: resource.content };
+  }
+  return {
+    kind: "github",
+    repository: `${resource.repository.owner}/${resource.repository.repo}`,
+    path: resource.path,
+    ref: resource.commit,
+    ...resource.name ? { name: resource.name } : {}
+  };
+}
+function publicValue(value) {
+  return value.value;
+}
+function mapPublicValues(values) {
+  return Object.fromEntries(Object.entries(values).map(([key, value]) => [key, publicValue(value)]));
+}
+function mapRecord(values) {
+  return Object.fromEntries(
+    Object.entries(values).map(([key, value]) => [key, { ...value }])
+  );
+}
+function shellQuote(value) {
+  return /^[A-Za-z0-9_./:@%+=,-]+$/.test(value) ? value : `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function verifyAgentImprovementReview(input) {
+  if (!isRecord(input) || input.kind !== "agent-improvement-review" || input.schemaVersion !== 1) {
+    throw new Error("invalid agent improvement review");
+  }
+  const review = input;
+  if (!isSha256Digest(review.digest) || !isSha256Digest(review.proposalDigest)) {
+    throw new Error("candidate review digest is invalid");
+  }
+  if (review.candidateBundleDigest !== void 0 && !isSha256Digest(review.candidateBundleDigest)) {
+    throw new Error("candidate review bundle digest is invalid");
+  }
+  if (!["approve", "reject", "request-changes"].includes(review.decision)) {
+    throw new Error("candidate review decision is invalid");
+  }
+  const actual = canonicalCandidateDigest(omitTopLevelDigest(review));
+  if (actual !== review.digest) throw new Error("agent improvement review digest does not match");
+  return immutableCandidateValue(review);
+}
+function improvementEvaluation(result) {
+  return {
+    baseline: result.baseline,
+    winner: result.winner,
+    lift: result.lift,
+    diff: result.diff,
+    provenance: result.provenance,
+    gateDecision: result.gateDecision,
+    generationsExplored: result.generationsExplored,
+    durationMs: result.durationMs,
+    totalCostUsd: result.totalCostUsd,
+    insight: result.insight,
+    ...result.power === void 0 ? {} : { power: result.power }
+  };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isSha256Digest(value) {
+  return typeof value === "string" && /^sha256:[a-f0-9]{64}$/.test(value);
+}
+function canonicalJsonValue(value, path = "$") {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error(`non-finite number at ${path}`);
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry, index) => {
+      if (entry === void 0) throw new Error(`undefined array entry at ${path}[${index}]`);
+      return canonicalJsonValue(entry, `${path}[${index}]`);
+    });
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).filter(([, entry]) => entry !== void 0).map(([key, entry]) => [key, canonicalJsonValue(entry, `${path}.${key}`)]);
+    return Object.fromEntries(entries);
+  }
+  throw new Error(`unsupported proposal value at ${path}`);
+}
+
 // src/intelligence/resolver.ts
 function emptyAccumulator() {
   return {
@@ -762,6 +1094,46 @@ async function composeCertifiedProfileFromWire(base, profile, ctx = {}) {
 
 // src/intelligence/with-intelligence.ts
 import { applyAgentProfileDiff } from "@tangle-network/agent-interface";
+function summarizeRuntimeEvents(events) {
+  const summary = { inferenceUsd: 0, inputTokens: 0, outputTokens: 0 };
+  for (const event of events) {
+    if ("session" in event && event.session) summary.sessionId = event.session.id;
+    if (event.type === "llm_call") {
+      summary.model = event.model;
+      summary.inferenceUsd += event.costUsd ?? 0;
+      summary.inputTokens += event.tokensIn ?? 0;
+      summary.outputTokens += event.tokensOut ?? 0;
+    } else if (event.type === "backend_error") {
+      summary.success = false;
+      summary.error = {
+        name: event.error?.kind ?? "BackendError",
+        message: event.message,
+        ...event.error?.status !== void 0 ? { code: String(event.error.status) } : {}
+      };
+    } else if (event.type === "final") {
+      summary.success = event.status === "completed";
+      if (event.error) {
+        summary.error = {
+          name: event.error.kind,
+          message: event.error.message,
+          ...event.error.status !== void 0 ? { code: String(event.error.status) } : {}
+        };
+      }
+    }
+  }
+  return summary;
+}
+function runError(cause) {
+  if (cause instanceof Error) {
+    const code = cause.code;
+    return {
+      name: cause.name || "Error",
+      message: cause.message,
+      ...typeof code === "string" || typeof code === "number" ? { code: String(code) } : {}
+    };
+  }
+  return { name: "Error", message: String(cause) };
+}
 function withIntelligence(agent, config) {
   const client = createIntelligenceClient(config);
   const target = config.target ?? config.project;
@@ -788,43 +1160,70 @@ function withIntelligence(agent, config) {
     signalProposals();
   }
   const wrapped = (async (input) => {
+    const runId = client.freshRunId();
+    const traceId = client.freshTraceId();
+    const startedAt = Date.now();
     await refresh();
     const certified = source.current();
     const proposals = currentProposals();
     const report = {};
     const applied = {
+      runId,
+      traceId,
       certified,
       composePrompt: (base) => composeCertifiedPrompt(base, certified),
       proposals,
       applyProfile: (base) => proposals.reduce((profile, p) => applyAgentProfileDiff(profile, p.diff), base),
       record: (r) => Object.assign(report, r)
     };
-    const output = await agent(input, applied);
-    const usage = {
-      inferenceUsd: report.usage?.inferenceUsd ?? report.costUsd ?? 0,
-      intelligenceUsd: report.usage?.intelligenceUsd ?? 0
-    };
-    const record = {
-      runId: client.freshRunId(),
-      traceId: client.freshTraceId(),
-      project: config.project,
-      target,
-      input,
-      output,
-      outcome: {
-        ...report.success !== void 0 ? { success: report.success } : {},
-        ...report.score !== void 0 ? { score: report.score } : {},
-        usage
-      },
-      ...report.model !== void 0 ? { model: report.model } : {},
-      ...report.provider !== void 0 ? { provider: report.provider } : {},
-      ...report.loopEvents !== void 0 ? { loopEvents: report.loopEvents } : {}
-    };
-    client.exportRunRecord(record);
-    return output;
+    function exportCompleted(output, caught) {
+      const completedAt = Date.now();
+      const eventSummary = summarizeRuntimeEvents(report.runtimeEvents ?? []);
+      const error = report.error ?? (caught !== void 0 ? runError(caught) : eventSummary.error);
+      const tokens = report.tokens ?? (eventSummary.inputTokens > 0 || eventSummary.outputTokens > 0 ? { input: eventSummary.inputTokens, output: eventSummary.outputTokens } : void 0);
+      const profile = report.profile ?? config.profile;
+      const record = {
+        runId,
+        traceId,
+        project: config.project,
+        target,
+        input,
+        output,
+        outcome: {
+          success: report.success ?? (caught !== void 0 ? false : eventSummary.success ?? error === void 0),
+          ...report.score !== void 0 ? { score: report.score } : {},
+          usage: {
+            inferenceUsd: report.usage?.inferenceUsd ?? report.costUsd ?? eventSummary.inferenceUsd,
+            intelligenceUsd: report.usage?.intelligenceUsd ?? 0
+          }
+        },
+        timing: { startedAt, completedAt, durationMs: completedAt - startedAt },
+        ...report.model ?? eventSummary.model ? { model: report.model ?? eventSummary.model } : {},
+        ...report.provider !== void 0 ? { provider: report.provider } : {},
+        ...report.loopEvents !== void 0 ? { loopEvents: report.loopEvents } : {},
+        ...report.runtimeEvents !== void 0 ? { runtimeEvents: report.runtimeEvents } : {},
+        ...profile !== void 0 ? { profile } : {},
+        ...report.sessionId ?? eventSummary.sessionId ? { sessionId: report.sessionId ?? eventSummary.sessionId } : {},
+        ...report.harness ?? profile?.harness ? { harness: report.harness ?? profile?.harness } : {},
+        ...report.commitSha ?? config.commitSha ? { commitSha: report.commitSha ?? config.commitSha } : {},
+        ...tokens !== void 0 ? { tokens } : {},
+        ...error !== void 0 ? { error } : {},
+        ...report.candidateExecution !== void 0 ? { candidateExecution: report.candidateExecution } : {}
+      };
+      client.exportRunRecord(record);
+    }
+    try {
+      const output = await agent(input, applied);
+      exportCompleted(output);
+      return output;
+    } catch (cause) {
+      exportCompleted(void 0, cause);
+      throw cause;
+    }
   });
   wrapped.refresh = refresh;
   wrapped.proposals = currentProposals;
+  wrapped.flush = client.flush;
   return wrapped;
 }
 
@@ -840,8 +1239,7 @@ function freshTraceId() {
 function freshRunId() {
   return `run-${randomHex(16)}`;
 }
-var previewMaxChars = 4096;
-function previewJson(value) {
+function serializeJson(value) {
   let s;
   if (typeof value === "string") s = value;
   else {
@@ -851,7 +1249,13 @@ function previewJson(value) {
       s = String(value);
     }
   }
-  return s.length > previewMaxChars ? `${s.slice(0, previewMaxChars)}\u2026[truncated]` : s;
+  return s;
+}
+function addPayloadAttributes(labels, key, value, includeFullPayload) {
+  const serialized = serializeJson(value);
+  labels[`${key}_hash`] = contentHash(serialized);
+  labels[`${key}_bytes`] = Buffer.byteLength(serialized, "utf8");
+  if (includeFullPayload) labels[key] = serialized;
 }
 function randomHex(chars) {
   const bytes = new Uint8Array(Math.ceil(chars / 2));
@@ -869,6 +1273,7 @@ function createIntelligenceClient(config) {
   const effort = resolveEffortConfig(config.effort);
   const intelligenceOff = isIntelligenceOff(effort);
   const redactor = resolveRedactor(config.redact);
+  const includeFullPayload = config.payloadAttributes === "full";
   const apiKey = config.apiKey ?? (typeof process !== "undefined" ? process.env.TANGLE_API_KEY : void 0);
   const otlpEndpoint = `${resolveIntelligenceBaseUrl(config.baseUrl)}/v1/otlp`;
   let exporter;
@@ -888,22 +1293,26 @@ function createIntelligenceClient(config) {
   function exportTrace(meta, outcome, output) {
     const ex = getExporter();
     if (!ex) return;
-    const labels = {
-      project: config.project,
-      "tangle.effort.intelligence_off": outcome.intelligenceOff,
-      "tangle.usage.inference_usd": outcome.usage.inferenceUsd,
-      "tangle.usage.intelligence_usd": outcome.usage.intelligenceUsd,
-      ...meta.model ? { "gen_ai.request.model": meta.model } : {},
-      ...meta.provider ? { "provider.name": meta.provider } : {},
-      ...typeof outcome.success === "boolean" ? { "tangle.outcome.success": outcome.success } : {},
-      ...typeof outcome.score === "number" ? { "tangle.outcome.score": outcome.score } : {},
-      ...meta.labels ?? {}
-    };
-    const redactedInput = meta.input !== void 0 ? redactor(meta.input) : void 0;
-    const redactedOutput = output !== void 0 ? redactor(output) : void 0;
-    if (redactedInput !== void 0) labels["tangle.input"] = previewJson(redactedInput);
-    if (redactedOutput !== void 0) labels["tangle.output"] = previewJson(redactedOutput);
     try {
+      const labels = {
+        project: config.project,
+        "tangle.effort.intelligence_off": outcome.intelligenceOff,
+        "tangle.usage.inference_usd": outcome.usage.inferenceUsd,
+        "tangle.usage.intelligence_usd": outcome.usage.intelligenceUsd,
+        ...meta.model ? { "gen_ai.request.model": meta.model } : {},
+        ...meta.provider ? { "provider.name": meta.provider } : {},
+        ...typeof outcome.success === "boolean" ? { "tangle.outcome.success": outcome.success } : {},
+        ...typeof outcome.score === "number" ? { "tangle.outcome.score": outcome.score } : {},
+        ...meta.labels ?? {}
+      };
+      const redactedInput = meta.input !== void 0 ? redactor(meta.input) : void 0;
+      const redactedOutput = output !== void 0 ? redactor(output) : void 0;
+      if (redactedInput !== void 0) {
+        addPayloadAttributes(labels, "tangle.input", redactedInput, includeFullPayload);
+      }
+      if (redactedOutput !== void 0) {
+        addPayloadAttributes(labels, "tangle.output", redactedOutput, includeFullPayload);
+      }
       ex.exportSpan(
         flatOtelSpan(
           "tangle.intelligence.run",
@@ -918,30 +1327,92 @@ function createIntelligenceClient(config) {
   function exportRunRecord(record) {
     const ex = getExporter();
     if (!ex) return record.traceId;
-    const intelligenceUsd = intelligenceOff ? 0 : record.outcome.usage.intelligenceUsd;
-    const labels = {
-      project: record.project,
-      "tangle.target": record.target,
-      "tangle.effort.intelligence_off": intelligenceOff,
-      "tangle.usage.inference_usd": record.outcome.usage.inferenceUsd,
-      "tangle.usage.intelligence_usd": intelligenceUsd,
-      ...record.model ? { "gen_ai.request.model": record.model } : {},
-      ...record.provider ? { "provider.name": record.provider } : {},
-      ...typeof record.outcome.success === "boolean" ? { "tangle.outcome.success": record.outcome.success } : {},
-      ...typeof record.outcome.score === "number" ? { "tangle.outcome.score": record.outcome.score } : {}
-    };
-    const redactedInput = record.input !== void 0 ? redactor(record.input) : void 0;
-    const redactedOutput = record.output !== void 0 ? redactor(record.output) : void 0;
-    if (redactedInput !== void 0) labels["tangle.input"] = previewJson(redactedInput);
-    if (redactedOutput !== void 0) labels["tangle.output"] = previewJson(redactedOutput);
     try {
+      const intelligenceUsd = intelligenceOff ? 0 : record.outcome.usage.intelligenceUsd;
+      const repository = record.repository ?? (config.repo ? `${config.repo.owner}/${config.repo.name}` : void 0);
+      const labels = {
+        project: record.project,
+        "tangle.target": record.target,
+        "tangle.effort.intelligence_off": intelligenceOff,
+        "tangle.usage.inference_usd": record.outcome.usage.inferenceUsd,
+        "tangle.usage.intelligence_usd": intelligenceUsd,
+        ...record.model ? { "gen_ai.request.model": record.model } : {},
+        ...record.provider ? { "provider.name": record.provider } : {},
+        ...record.sessionId ? {
+          "tangle.sessionId": record.sessionId,
+          "gen_ai.conversation.id": record.sessionId
+        } : {},
+        ...record.harness ? { "tangle.agent.harness": record.harness } : {},
+        ...repository ? { "vcs.repository.name": repository } : {},
+        ...record.commitSha ? { "vcs.ref.head.revision": record.commitSha } : {},
+        ...record.timing ? {
+          "tangle.started_at_ms": record.timing.startedAt,
+          "tangle.completed_at_ms": record.timing.completedAt,
+          "tangle.duration_ms": record.timing.durationMs
+        } : {},
+        ...record.tokens ? {
+          "gen_ai.usage.input_tokens": record.tokens.input,
+          "gen_ai.usage.output_tokens": record.tokens.output,
+          ...record.tokens.cachedInput !== void 0 ? { "gen_ai.usage.cache_read_input_tokens": record.tokens.cachedInput } : {},
+          ...record.tokens.reasoning !== void 0 ? { "gen_ai.usage.reasoning_tokens": record.tokens.reasoning } : {}
+        } : {},
+        ...typeof record.outcome.success === "boolean" ? { "tangle.outcome.success": record.outcome.success } : {},
+        ...typeof record.outcome.score === "number" ? { "tangle.outcome.score": record.outcome.score } : {},
+        ...record.error ? {
+          "error.type": record.error.code ?? record.error.name,
+          "error.message": serializeJson(redactor(record.error.message))
+        } : {},
+        ...record.runtimeEvents ? { "tangle.runtime.event_count": record.runtimeEvents.length } : {},
+        ...record.candidateExecution ? {
+          "tangle.candidate.proposal_digest": record.candidateExecution.proposalDigest,
+          "tangle.candidate.review_digest": record.candidateExecution.reviewDigest,
+          "tangle.candidate.bundle_digest": record.candidateExecution.bundleDigest,
+          "tangle.candidate.execution_id": record.candidateExecution.executionId,
+          "tangle.candidate.execution_plan_digest": record.candidateExecution.executionPlanDigest,
+          "tangle.candidate.materialization_receipt_digest": record.candidateExecution.materializationReceiptDigest,
+          "tangle.candidate.succeeded": record.candidateExecution.succeeded,
+          ...record.candidateExecution.runReceiptDigest ? {
+            "tangle.candidate.run_receipt_digest": record.candidateExecution.runReceiptDigest
+          } : {}
+        } : {}
+      };
+      if (record.profile) {
+        addPayloadAttributes(
+          labels,
+          "tangle.agent.profile",
+          redactor(record.profile),
+          includeFullPayload
+        );
+        labels["tangle.agent.profile_hash"] = contentHash(record.profile);
+        if (record.profile.name) labels["gen_ai.agent.name"] = record.profile.name;
+      }
+      const redactedInput = record.input !== void 0 ? redactor(record.input) : void 0;
+      const redactedOutput = record.output !== void 0 ? redactor(record.output) : void 0;
+      if (redactedInput !== void 0) {
+        addPayloadAttributes(labels, "tangle.input", redactedInput, includeFullPayload);
+      }
+      if (redactedOutput !== void 0) {
+        addPayloadAttributes(labels, "tangle.output", redactedOutput, includeFullPayload);
+      }
+      const now = Date.now();
       const runSpan = flatOtelSpan(
         "tangle.intelligence.run",
         { "tangle.runId": record.runId, ...labels },
         record.traceId,
-        Date.now()
+        record.timing?.startedAt ?? now,
+        void 0,
+        record.timing?.completedAt ?? now
       );
       ex.exportSpan(runSpan);
+      if (record.runtimeEvents && record.runtimeEvents.length > 0) {
+        const spans = buildRuntimeEventOtelSpans(
+          record.runtimeEvents,
+          record.traceId,
+          runSpan.spanId,
+          { ...config.runtimeTelemetry, redact: redactor }
+        );
+        for (const span of spans) ex.exportSpan(span);
+      }
       if (record.loopEvents && record.loopEvents.length > 0) {
         const spans = buildLoopOtelSpans(
           record.loopEvents,
@@ -1062,13 +1533,18 @@ export {
   createIntelligenceClient,
   defaultEffortTier,
   defaultRedactor,
+  executeApprovedAgentCandidate,
   isIntelligenceOff,
   manifestFromProfile,
   normalizeCertifiedProfile,
+  proposeAgentImprovement,
   pullCertified,
   resolveEffort,
   resolveIntelligenceBaseUrl,
   resolveRedactor,
+  reviewAgentImprovementProposal,
+  verifyAgentImprovementProposal,
+  verifyAgentImprovementReview,
   withIntelligence
 };
 //# sourceMappingURL=intelligence.js.map