@graphrefly/ts 0.0.1 → 0.0.3

package/dist/chunk-WOS7RJYZ.js

@@ -0,0 +1,1320 @@
+import {
+  adapterRuntimeIssue,
+  agentRequestStatusForExecutorOutcome,
+  buildToolProviderExecutorOutcome,
+  defaultToolProviderAdapterEvidenceRefs,
+  normalizeToolProviderAdapterBindings,
+  outcomeIssues,
+  runRequestIdentityIssues,
+  toolProviderAdapterRunProjectorInternal
+} from "./chunk-7GOTIIQ7.js";
+import {
+  boundPublicText,
+  canonicalPublicSourceRefs,
+  dataIssue,
+  isPlainRecord,
+  isRecord,
+  maxPublicMetadataStringChars,
+  publicMaterialForbiddenKeys,
+  ref,
+  sanitizeAdapterInputIssue,
+  sanitizeAdapterInputSourceRefs,
+  sanitizeGraphVisibleRecord,
+  sanitizeProviderGraphVisibleRecord,
+  stableStringHash
+} from "./chunk-TQPCAIQI.js";
+import {
+  PolicyInputs,
+  selectRetentionVictims,
+  trimHeadOverflow
+} from "./chunk-6E76H4OU.js";
+import {
+  Node
+} from "./chunk-GXU6WFEJ.js";
+
+// src/orchestration/agent-runtime-adapter-retention.ts
+var RuntimeRetentionIndex = class {
+  items = /* @__PURE__ */ new Map();
+  get size() {
+    return this.items.size;
+  }
+  get(key) {
+    return this.items.get(key);
+  }
+  has(key) {
+    return this.items.has(key);
+  }
+  set(key, entry, value) {
+    const item = { key, entry, value };
+    this.items.set(key, item);
+    return item;
+  }
+  delete(key) {
+    const item = this.items.get(key);
+    if (item !== void 0) this.items.delete(key);
+    return item;
+  }
+  trimFifo(maxSize) {
+    const items = Array.from(this.items.values()).sort(
+      (a, b) => a.entry.sequence - b.entry.sequence
+    );
+    return trimHeadOverflow(items, { maxSize }).map((item) => this.delete(item.key)).filter((item) => item !== void 0);
+  }
+  trimScored(maxSize, score) {
+    const scored = [];
+    for (const item of this.items.values()) {
+      let value;
+      try {
+        value = score(item.entry);
+      } catch {
+        return { invalid: "threw" };
+      }
+      if (!Number.isFinite(value)) return { invalid: "non-finite" };
+      scored.push({ entry: item, score: value });
+    }
+    const victims = selectRetentionVictims(scored, { maxSize }).map(
+      (item) => this.delete(item.key)
+    );
+    return {
+      victims: victims.filter((item) => item !== void 0)
+    };
+  }
+};
+var toolProviderAdapterRuntimeRetentionIndexes = Object.freeze([
+  "adapterInputs",
+  "runRequests",
+  "executions",
+  "runStatuses",
+  "runIssues",
+  "retentionEvidence"
+]);
+function toolProviderAdapterRuntimeRetentionIndex(value) {
+  return toolProviderAdapterRuntimeRetentionIndexes.find((index) => index === value);
+}
+function isNodeOpt(value) {
+  return value instanceof Node;
+}
+function retentionIndexSourceRef(index) {
+  return { kind: "tool-provider-adapter-runtime-retention-index", id: index };
+}
+function runtimeEvidenceSourceRefs(index, refs = []) {
+  return canonicalPublicSourceRefs([...refs, retentionIndexSourceRef(index)]);
+}
+function runtimeEvidenceMetadata(index, opts = {}) {
+  return {
+    index,
+    ...opts.key === void 0 ? {} : { key: runtimeDiagnosticKey(opts.key) },
+    ...opts.extra ?? {}
+  };
+}
+function runtimeDiagnosticKey(key) {
+  return `key:${stableStringHash(key)}:${key.length}`;
+}
+var maxRuntimeRetentionScorerStringChars = 256;
+function runtimeRetentionScorerEntry(index, entry) {
+  if (!isPlainRecord(entry) || publicMaterialForbiddenKeys(entry, "provider").length > 0) {
+    throw new TypeError(`unsafe ${index} retention scorer entry`);
+  }
+  const bounded = {};
+  for (const value of Object.values(entry)) {
+    if (value !== void 0 && typeof value !== "string" && typeof value !== "number") {
+      throw new TypeError(`unsafe ${index} retention scorer entry`);
+    }
+  }
+  for (const [key, value] of Object.entries(entry)) {
+    bounded[key] = key === "key" && typeof value === "string" ? runtimeDiagnosticKey(value) : typeof value === "string" && value.length > maxRuntimeRetentionScorerStringChars ? `bounded:${stableStringHash(value)}:${value.length}` : value;
+  }
+  return Object.freeze(bounded);
+}
+function retentionPolicyMaxSize(policy) {
+  return policy?.maxSize;
+}
+function retentionPolicyMode(policy) {
+  if (policy === void 0) return void 0;
+  return "score" in policy && policy.score !== void 0 ? "score" : "fifo";
+}
+function buildRetentionPolicyReaders(graph, name, retention) {
+  const inputs = new PolicyInputs();
+  const readers = /* @__PURE__ */ new Map();
+  const statics = /* @__PURE__ */ new Map();
+  for (const index of toolProviderAdapterRuntimeRetentionIndexes) {
+    const policy = retention?.[index];
+    const maxSize = retentionPolicyMaxSize(policy);
+    if (maxSize === void 0) {
+      statics.set(index, void 0);
+      readers.set(index, inputs.add(void 0));
+      continue;
+    }
+    const node = isNodeOpt(maxSize) ? maxSize : graph.node([], null, {
+      name: `${name}/retentionPolicy/${index}/maxSize`,
+      factory: "toolProviderAdapterRuntimeRetentionPolicy.maxSize",
+      initial: maxSize
+    });
+    if (!isNodeOpt(maxSize)) statics.set(index, maxSize);
+    readers.set(index, inputs.add(node));
+  }
+  return { inputs, readers, statics };
+}
+function readRetentionPolicyFact(ctx, retention, readers, current) {
+  const policies = /* @__PURE__ */ new Map();
+  const issues = [];
+  for (const index of toolProviderAdapterRuntimeRetentionIndexes) {
+    const raw = retention?.[index];
+    if (raw === void 0) continue;
+    const reader = readers.readers.get(index);
+    const previous = current?.policies.get(index)?.maxSize ?? readers.statics.get(index);
+    const maxSize = reader?.read(ctx, previous);
+    const issue = validateRuntimeRetentionPolicy(index, raw, maxSize);
+    if (issue !== void 0) {
+      issues.push(issue);
+      continue;
+    }
+    policies.set(index, {
+      maxSize,
+      mode: retentionPolicyMode(raw) ?? "fifo"
+    });
+  }
+  return {
+    kind: "tool-provider-adapter-runtime-retention-policy",
+    policies,
+    ...issues.length === 0 ? {} : { issues: Object.freeze(issues) }
+  };
+}
+function validateRuntimeRetentionPolicy(index, policy, maxSize) {
+  if ("score" in policy && policy.score !== void 0 && typeof policy.score !== "function")
+    return invalidRetentionPolicyIssue(index, "score must be a function");
+  if (!("score" in policy) || policy.score === void 0) {
+    const order = policy.order ?? "fifo";
+    if (order !== "fifo") return invalidRetentionPolicyIssue(index, "order must be fifo");
+  }
+  if (maxSize === void 0 || !Number.isSafeInteger(maxSize) || maxSize < 1)
+    return invalidRetentionPolicyIssue(index, "maxSize must be a safe integer >= 1");
+  return void 0;
+}
+function invalidRetentionPolicyIssue(index, reason) {
+  return dataIssue(
+    "tool-provider-adapter-runtime-invalid-retention-policy",
+    "Tool provider adapter runtime retention policy is invalid; last-known-good policy remains active.",
+    {
+      subjectId: index,
+      refs: [retentionIndexSourceRef(index)],
+      details: { index, reason },
+      severity: "warning"
+    }
+  );
+}
+function adapterInputRetentionEntry(key, sequence, input, insertedAtMs) {
+  return Object.freeze({
+    key,
+    sequence,
+    ...insertedAtMs === void 0 ? {} : { insertedAtMs },
+    adapterInputId: input.adapterInputId,
+    requestId: input.requestId,
+    operationId: input.operationId,
+    ...input.routeId === void 0 ? {} : { routeId: input.routeId },
+    ...input.providerId === void 0 ? {} : { providerId: input.providerId },
+    ...input.executorId === void 0 ? {} : { executorId: input.executorId },
+    ...input.profileId === void 0 ? {} : { profileId: input.profileId },
+    status: input.status
+  });
+}
+function runRequestRetentionEntry(key, sequence, request) {
+  return Object.freeze({
+    key,
+    sequence,
+    ...request.requestedAtMs === void 0 ? {} : { requestedAtMs: request.requestedAtMs },
+    adapterInputId: request.adapterInputId,
+    runId: request.runId,
+    attempt: request.attempt,
+    requestId: request.requestId,
+    operationId: request.operationId,
+    ...request.routeId === void 0 ? {} : { routeId: request.routeId },
+    ...request.providerId === void 0 ? {} : { providerId: request.providerId },
+    ...request.executorId === void 0 ? {} : { executorId: request.executorId },
+    ...request.profileId === void 0 ? {} : { profileId: request.profileId },
+    reason: request.reason
+  });
+}
+function executionRetentionEntry(key, sequence, request, status, occurredAtMs, outcomeId) {
+  return Object.freeze({
+    key,
+    sequence,
+    ...occurredAtMs === void 0 ? {} : { occurredAtMs },
+    adapterInputId: request.adapterInputId,
+    runId: request.runId,
+    attempt: request.attempt,
+    requestId: request.requestId,
+    operationId: request.operationId,
+    ...request.routeId === void 0 ? {} : { routeId: request.routeId },
+    ...request.providerId === void 0 ? {} : { providerId: request.providerId },
+    ...request.executorId === void 0 ? {} : { executorId: request.executorId },
+    ...request.profileId === void 0 ? {} : { profileId: request.profileId },
+    ...outcomeId === void 0 ? {} : { outcomeId },
+    status,
+    reason: request.reason
+  });
+}
+function runStatusRetentionEntry(key, sequence, status, occurredAtMs) {
+  const issueCode = status.issues?.[0]?.code;
+  return Object.freeze({
+    key,
+    sequence,
+    ...occurredAtMs === void 0 ? {} : { occurredAtMs },
+    adapterInputId: status.adapterInputId,
+    runId: status.runId,
+    ...status.attempt === void 0 ? {} : { attempt: status.attempt },
+    ...status.requestId === void 0 ? {} : { requestId: status.requestId },
+    ...status.operationId === void 0 ? {} : { operationId: status.operationId },
+    status: status.status,
+    ...status.outcomeId === void 0 ? {} : { outcomeId: status.outcomeId },
+    ...issueCode === void 0 ? {} : { issueCode }
+  });
+}
+function runIssueRetentionEntry(key, sequence, issue, occurredAtMs, context = {}) {
+  return Object.freeze({
+    key,
+    sequence,
+    ...occurredAtMs === void 0 ? {} : { occurredAtMs },
+    ...context.adapterInputId === void 0 ? {} : { adapterInputId: context.adapterInputId },
+    ...context.runId === void 0 ? {} : { runId: context.runId },
+    ...context.attempt === void 0 ? {} : { attempt: context.attempt },
+    ...context.requestId === void 0 ? {} : { requestId: context.requestId },
+    ...context.operationId === void 0 ? {} : { operationId: context.operationId },
+    issueCode: issue.code,
+    ...issue.severity === void 0 ? {} : { severity: issue.severity },
+    ...issue.subjectId === void 0 ? {} : { subjectId: issue.subjectId }
+  });
+}
+function retentionEvidenceEntry(key, sequence, opts) {
+  return Object.freeze({
+    key,
+    sequence,
+    ...opts.occurredAtMs === void 0 ? {} : { occurredAtMs: opts.occurredAtMs },
+    adapterInputId: opts.adapterInputId,
+    evidenceKind: opts.evidenceKind,
+    ...opts.attemptHighWater === void 0 ? {} : { attemptHighWater: opts.attemptHighWater },
+    reason: opts.reason
+  });
+}
+
+// src/orchestration/agent-runtime-adapter-runtime-execute.ts
+function runAdapterRuntimeRequest(ctx, request) {
+  if (ctx.isDisposed()) return;
+  const input = ctx.adapterInputs.get(request.adapterInputId)?.value;
+  if (input === void 0) {
+    const missingInputClassification = ctx.classifyRunRequestReplayEvidence(request);
+    ctx.publishReplayClassification(request, missingInputClassification);
+    return;
+  }
+  if (input.status !== "ready") {
+    const issue = dataIssue(
+      "tool-provider-adapter-runtime-input-not-ready",
+      "Tool provider adapter runtime requires a ready adapter input.",
+      {
+        subjectId: input.requestId,
+        refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+        details: { status: input.status }
+      }
+    );
+    ctx.publishIssue(issue);
+    ctx.publishRunStatus(request, "stale-request", [issue]);
+    ctx.publishStatus(input, "blocked", [issue]);
+    return;
+  }
+  const requestIssues = runRequestIdentityIssues(request, input);
+  if (requestIssues.length > 0) {
+    for (const issue of requestIssues) ctx.publishIssue(issue);
+    ctx.publishRunStatus(request, "mismatched-request", requestIssues);
+    ctx.publishStatus(input, "blocked", requestIssues);
+    ctx.publishAudit(input, "tool-provider-adapter-runtime-run-request-rejected", {
+      runId: request.runId,
+      attempt: request.attempt,
+      issueCodes: requestIssues.map((issue) => issue.code)
+    });
+    return;
+  }
+  if (ctx.executions.has(ctx.executionCoordinate(request))) {
+    ctx.startExecutionProof(request);
+    return;
+  }
+  const classification = ctx.classifyRunRequestReplayEvidence(request, input);
+  if (ctx.publishReplayClassification(request, classification)) return;
+  if (!ctx.startExecutionProof(request)) return;
+  const binding = input.providerId === void 0 ? void 0 : ctx.bindings.get(input.providerId);
+  if (binding === void 0) {
+    const issue = dataIssue(
+      "tool-provider-adapter-runtime-missing-binding",
+      "Tool provider adapter runtime requires a matching runtime-private binding.",
+      {
+        subjectId: input.requestId,
+        refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+        details: { providerId: input.providerId }
+      }
+    );
+    ctx.publishOutcome(
+      input,
+      {
+        kind: "blocked",
+        needs: [
+          {
+            kind: "tool-provider-binding",
+            message: "Matching runtime-private tool provider binding is unavailable.",
+            ...input.providerId === void 0 ? {} : { refs: [ref("tool-provider", input.providerId)] }
+          }
+        ],
+        issues: [issue]
+      },
+      request
+    );
+    return;
+  }
+  ctx.publishRunStatus(request, "started");
+  ctx.publishStatus(input, "in-flight");
+  ctx.publishAudit(input, "tool-provider-adapter-runtime-started", {
+    providerId: binding.providerId,
+    runId: request.runId,
+    attempt: request.attempt,
+    reason: request.reason
+  });
+  let result;
+  try {
+    result = binding.run(input, {
+      runId: request.runId,
+      attempt: request.attempt,
+      reason: request.reason,
+      sourceRefs: request.sourceRefs ?? input.sourceRefs ?? [],
+      now: ctx.now
+    });
+  } catch (error) {
+    ctx.publishRuntimeFailure(input, request, "tool-provider-adapter-runtime-threw", error);
+    return;
+  }
+  if (isThenableResult(result)) {
+    ctx.publishRuntimeFailure(
+      input,
+      request,
+      "tool-provider-adapter-runtime-async-result-unsupported",
+      new Error("Tool provider adapter runtime bindings must return synchronously.")
+    );
+    return;
+  }
+  ctx.publishOutcome(input, result, request);
+}
+function isThenableResult(value) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") return false;
+  try {
+    return typeof value.then === "function";
+  } catch {
+    return true;
+  }
+}
+
+// src/orchestration/agent-runtime-adapter-runtime-retention-gaps.ts
+function retentionGapIssueCode(gapKind) {
+  switch (gapKind) {
+    case "evidence-horizon":
+      return "tool-provider-adapter-runtime-retention-evidence-gap";
+    case "evidence-horizon-closed":
+      return "tool-provider-adapter-runtime-retention-evidence-horizon-closed";
+    case "adapter-input-trimmed":
+    case "execution-proof-trimmed":
+      return "tool-provider-adapter-runtime-retention-gap";
+  }
+}
+function retentionGapMessage(gapKind) {
+  switch (gapKind) {
+    case "evidence-horizon":
+      return "Tool provider adapter runtime retention evidence horizon no longer proves this request is fresh.";
+    case "evidence-horizon-closed":
+      return "Tool provider adapter runtime retention evidence horizon is closed; this request must fail closed.";
+    case "adapter-input-trimmed":
+      return "Tool provider adapter runtime retention removed the requested adapter input proof.";
+    case "execution-proof-trimmed":
+      return "Tool provider adapter runtime retention removed execution proof needed to safely replay this request.";
+  }
+}
+function retentionGapEvidenceKind(gapKind) {
+  switch (gapKind) {
+    case "adapter-input-trimmed":
+      return "adapter-input-trimmed";
+    case "execution-proof-trimmed":
+      return "execution-high-water";
+    case "evidence-horizon":
+    case "evidence-horizon-closed":
+      return void 0;
+  }
+}
+function publishAdapterRuntimeRetentionGap(ctx, request, classification) {
+  const { index, gapKind } = classification;
+  const key = classification.key ?? request.adapterInputId;
+  const issueCode = retentionGapIssueCode(gapKind);
+  const evidenceKind = retentionGapEvidenceKind(gapKind);
+  const sourceRefs = runtimeEvidenceSourceRefs(index, [
+    ref("tool-provider-adapter-run", request.runId),
+    ref("tool-provider-adapter-input", request.adapterInputId)
+  ]);
+  const metadata = runtimeEvidenceMetadata(index, {
+    key,
+    extra: {
+      gapKind,
+      ...evidenceKind === void 0 ? {} : { evidenceKind }
+    }
+  });
+  const issue = dataIssue(issueCode, retentionGapMessage(gapKind), {
+    subjectId: request.adapterInputId,
+    refs: sourceRefs,
+    details: {
+      index,
+      adapterInputId: request.adapterInputId,
+      runId: request.runId,
+      attempt: request.attempt,
+      issueCode,
+      gapKind,
+      key: runtimeDiagnosticKey(key),
+      ...evidenceKind === void 0 ? {} : { evidenceKind }
+    }
+  });
+  ctx.publishIssue(issue);
+  ctx.publishRunStatus(request, "retention-gap", [issue]);
+  ctx.publishRuntimeStatus({
+    status: "retention-gap",
+    index,
+    key,
+    adapterInputId: request.adapterInputId,
+    runId: request.runId,
+    attempt: request.attempt,
+    issueCode: issue.code,
+    sourceRefs,
+    metadata
+  });
+  ctx.publishRuntimeAudit("tool-provider-adapter-runtime-retention-gap", {
+    subjectId: request.adapterInputId,
+    sourceRefs,
+    issueCode: issue.code,
+    metadata
+  });
+}
+function publishAdapterRuntimeRetentionEvidenceGlobalFailClosed(ctx, victim) {
+  const sourceRefs = runtimeEvidenceSourceRefs("retentionEvidence");
+  const metadata = runtimeEvidenceMetadata("retentionEvidence", {
+    key: victim.key,
+    extra: {
+      evidenceKind: victim.value.evidenceKind,
+      gapKind: "evidence-horizon-closed"
+    }
+  });
+  const issue = dataIssue(
+    "tool-provider-adapter-runtime-retention-evidence-horizon-closed",
+    "Tool provider adapter runtime retention evidence closed-marker horizon overflowed; future requests fail closed until runtime reset.",
+    {
+      subjectId: victim.value.adapterInputId,
+      refs: sourceRefs,
+      details: {
+        index: "retentionEvidence",
+        key: runtimeDiagnosticKey(victim.key),
+        gapKind: "evidence-horizon-closed"
+      }
+    }
+  );
+  ctx.publishIssue(issue, false);
+  ctx.publishRuntimeStatus({
+    status: "retention-gap",
+    index: "retentionEvidence",
+    key: victim.key,
+    adapterInputId: victim.value.adapterInputId,
+    ...victim.value.attemptHighWater === void 0 ? {} : { attempt: victim.value.attemptHighWater },
+    issueCode: issue.code,
+    sourceRefs,
+    metadata
+  });
+  ctx.publishRuntimeAudit("tool-provider-adapter-runtime-retention-evidence-horizon-closed", {
+    subjectId: victim.value.adapterInputId,
+    sourceRefs,
+    issueCode: issue.code,
+    metadata
+  });
+}
+
+// src/orchestration/agent-runtime-adapter-runtime-state.ts
+function createAdapterRuntimeRetentionIndexes() {
+  return {
+    adapterInputs: new RuntimeRetentionIndex(),
+    runRequests: new RuntimeRetentionIndex(),
+    executions: new RuntimeRetentionIndex(),
+    runStatuses: new RuntimeRetentionIndex(),
+    runIssues: new RuntimeRetentionIndex(),
+    retentionEvidence: new RuntimeRetentionIndex(),
+    closedRetentionEvidence: new RuntimeRetentionIndex()
+  };
+}
+function createAdapterRuntimeOutputNodes(graph, name) {
+  return {
+    outcomes: graph.node([], null, {
+      name: `${name}/outcomes`,
+      factory: "toolProviderAdapterRuntimeOutcomes"
+    }),
+    runStatus: graph.node([], null, {
+      name: `${name}/runStatus`,
+      factory: "toolProviderAdapterRuntimeRunStatus"
+    }),
+    status: graph.node([], null, {
+      name: `${name}/status`,
+      factory: "toolProviderAdapterRuntimeStatus"
+    }),
+    runtimeStatus: graph.node([], null, {
+      name: `${name}/runtimeStatus`,
+      factory: "toolProviderAdapterRuntimeStatus"
+    }),
+    issues: graph.node([], null, {
+      name: `${name}/issues`,
+      factory: "toolProviderAdapterRuntimeIssues"
+    }),
+    audit: graph.node([], null, {
+      name: `${name}/audit`,
+      factory: "toolProviderAdapterRuntimeAudit"
+    })
+  };
+}
+
+// src/orchestration/agent-runtime-adapter-runtime.ts
+function attachToolProviderAdapterRuntime(graph, opts) {
+  const name = opts.name ?? "toolProviderAdapterRuntime";
+  const bindings = normalizeToolProviderAdapterBindings(opts.bindings);
+  const retentionReaders = buildRetentionPolicyReaders(graph, name, opts.retention);
+  const retentionPolicy = graph.node(
+    retentionReaders.inputs.deps,
+    (ctx) => {
+      const current = ctx.state.get();
+      const fact = readRetentionPolicyFact(ctx, opts.retention, retentionReaders, current);
+      ctx.state.set(fact);
+      ctx.down([["DATA", fact]]);
+    },
+    {
+      name: `${name}/retentionPolicy`,
+      factory: "toolProviderAdapterRuntimeRetentionPolicy",
+      partial: true
+    }
+  );
+  const {
+    adapterInputs,
+    runRequests,
+    executions,
+    runStatuses,
+    runIssues,
+    retentionEvidence,
+    closedRetentionEvidence
+  } = createAdapterRuntimeRetentionIndexes();
+  const executionHighWaterByInput = /* @__PURE__ */ new Map();
+  const trimmedAdapterInputIds = /* @__PURE__ */ new Set();
+  const projectorInputDropById = /* @__PURE__ */ new Map();
+  let retentionEvidenceHorizonExceeded = false;
+  const { outcomes, runStatus, status, runtimeStatus, issues, audit } = createAdapterRuntimeOutputNodes(graph, name);
+  let disposed = false;
+  let auditSeq = 0;
+  let retentionSeq = 0;
+  let effectiveRetention = {};
+  function nowMs() {
+    return opts.now?.();
+  }
+  function nextRetentionSequence() {
+    retentionSeq += 1;
+    return retentionSeq;
+  }
+  function publishRuntimeStatus(fact) {
+    const occurredAtMs = nowMs();
+    const { sourceRefs: rawSourceRefs, metadata: rawMetadata, key: rawKey, ...statusFields } = fact;
+    const sourceRefs = rawSourceRefs === void 0 ? void 0 : sanitizeAdapterInputSourceRefs(rawSourceRefs);
+    const metadata = sanitizeProviderGraphVisibleRecord(rawMetadata, opts.publicText);
+    const key = rawKey === void 0 ? void 0 : boundPublicText(
+      runtimeDiagnosticKey(rawKey),
+      maxPublicMetadataStringChars(opts.publicText)
+    ).text;
+    runtimeStatus.down([
+      [
+        "DATA",
+        {
+          kind: "tool-provider-adapter-runtime-status",
+          ...occurredAtMs === void 0 ? {} : { occurredAtMs },
+          ...statusFields,
+          ...key === void 0 ? {} : { key },
+          ...sourceRefs === void 0 ? {} : { sourceRefs },
+          ...metadata === void 0 ? {} : { metadata }
+        }
+      ]
+    ]);
+  }
+  function publishRuntimeAudit(kind, auditOpts = {}) {
+    auditSeq += 1;
+    const metadata = sanitizeProviderGraphVisibleRecord(auditOpts.metadata, opts.publicText);
+    audit.down([
+      [
+        "DATA",
+        {
+          id: `${name}:audit:${auditSeq}`,
+          kind,
+          ...auditOpts.subjectId === void 0 ? {} : { subjectId: auditOpts.subjectId },
+          ...auditOpts.sourceRefs === void 0 ? {} : { sourceRefs: sanitizeAdapterInputSourceRefs(auditOpts.sourceRefs) },
+          ...auditOpts.issueCode === void 0 ? {} : { issueCode: auditOpts.issueCode },
+          ...metadata === void 0 ? {} : { metadata }
+        }
+      ]
+    ]);
+  }
+  function trackRunIssue(issue, emittedKey, dropKey) {
+    const sequence = nextRetentionSequence();
+    const key = emittedKey ?? `${sequence}:${issue.code}:${issue.subjectId ?? ""}`;
+    runIssues.set(key, runIssueRetentionEntry(key, sequence, issue, nowMs()), {
+      fact: issue,
+      dropKey
+    });
+    trimRunIssues();
+  }
+  function publishIssue(issue, track = true) {
+    issues.down([["DATA", sanitizeAdapterInputIssue(issue)]]);
+    if (track) trackRunIssue(issue);
+  }
+  function publishRunStatus(request, nextStatus, statusIssues, outcomeId) {
+    const statusFact = {
+      kind: "tool-provider-adapter-run-status",
+      runId: request.runId,
+      adapterInputId: request.adapterInputId,
+      requestId: request.requestId,
+      operationId: request.operationId,
+      status: nextStatus,
+      attempt: request.attempt,
+      outcomeId,
+      issues: statusIssues,
+      sourceRefs: sanitizeAdapterInputSourceRefs(request.sourceRefs ?? []),
+      metadata: sanitizeGraphVisibleRecord(
+        {
+          providerId: request.providerId,
+          routeId: request.routeId,
+          reason: request.reason
+        },
+        opts.publicText
+      )
+    };
+    runStatus.down([["DATA", statusFact]]);
+    trackRunStatus(statusFact);
+  }
+  function trackRunStatus(statusFact, emittedKey, dropKey) {
+    const sequence = nextRetentionSequence();
+    const key = emittedKey ?? `${sequence}:${statusFact.runId}:${statusFact.status}`;
+    runStatuses.set(key, runStatusRetentionEntry(key, sequence, statusFact, nowMs()), {
+      fact: statusFact,
+      dropKey
+    });
+    trimRunStatuses();
+  }
+  function retentionScore(index) {
+    const policy = opts.retention?.[index];
+    return typeof policy?.score === "function" ? policy.score : void 0;
+  }
+  function trimRuntimeIndex(indexName, store, config, onVictim) {
+    if (config?.maxSize === void 0) return;
+    let victims;
+    if (config.mode === "score") {
+      const score = retentionScore(indexName);
+      if (score === void 0) return;
+      const selected = store.trimScored(config.maxSize, (entry) => {
+        return score(runtimeRetentionScorerEntry(indexName, entry));
+      });
+      if (selected.invalid !== void 0) {
+        publishRetentionScoreInvalid(indexName, selected.invalid);
+        return;
+      }
+      victims = selected.victims ?? [];
+    } else {
+      victims = store.trimFifo(config.maxSize);
+    }
+    for (const victim of victims) {
+      onVictim?.(victim);
+      publishRetentionTrimmed(indexName, victim.key, victim.entry);
+    }
+  }
+  function trackAdapterInputTrimmedEvidence(adapterInputId) {
+    trimmedAdapterInputIds.add(adapterInputId);
+    const sequence = nextRetentionSequence();
+    const key = `adapter-input-trimmed:${adapterInputId}`;
+    const entry = retentionEvidenceEntry(key, sequence, {
+      adapterInputId,
+      evidenceKind: "adapter-input-trimmed",
+      occurredAtMs: nowMs(),
+      reason: "adapter-input-retention"
+    });
+    retentionEvidence.set(key, entry, entry);
+    trimRetentionEvidence();
+  }
+  function trackExecutionHighWaterEvidence(adapterInputId, attempt) {
+    const previous = executionHighWaterByInput.get(adapterInputId) ?? 0;
+    const attemptHighWater = Math.max(previous, attempt);
+    executionHighWaterByInput.set(adapterInputId, attemptHighWater);
+    const sequence = nextRetentionSequence();
+    const key = `execution-high-water:${adapterInputId}`;
+    const entry = retentionEvidenceEntry(key, sequence, {
+      adapterInputId,
+      evidenceKind: "execution-high-water",
+      occurredAtMs: nowMs(),
+      attemptHighWater,
+      reason: "execution-proof-retention"
+    });
+    retentionEvidence.set(key, entry, entry);
+    trimRetentionEvidence();
+  }
+  function retentionEvidenceClosedKey(adapterInputId) {
+    return `closed:${adapterInputId}`;
+  }
+  function isRetentionEvidenceClosed(adapterInputId) {
+    return retentionEvidenceHorizonExceeded || closedRetentionEvidence.has(retentionEvidenceClosedKey(adapterInputId));
+  }
+  function classifyRunRequestReplayEvidence(request, input) {
+    if (isRetentionEvidenceClosed(request.adapterInputId)) {
+      return {
+        kind: "retention-gap",
+        index: "retentionEvidence",
+        gapKind: "evidence-horizon-closed",
+        key: retentionEvidenceClosedKey(request.adapterInputId)
+      };
+    }
+    if (input === void 0 && trimmedAdapterInputIds.has(request.adapterInputId)) {
+      return {
+        kind: "retention-gap",
+        index: "adapterInputs",
+        gapKind: "adapter-input-trimmed",
+        key: `adapter-input-trimmed:${request.adapterInputId}`
+      };
+    }
+    const highWater = executionHighWaterByInput.get(request.adapterInputId) ?? 0;
+    if (highWater >= request.attempt) {
+      return {
+        kind: "retention-gap",
+        index: "executions",
+        gapKind: "execution-proof-trimmed",
+        key: `execution-high-water:${request.adapterInputId}`
+      };
+    }
+    if (input === void 0) return { kind: "missing-input" };
+    return { kind: "fresh" };
+  }
+  function classifyRetainedRunRequestReplayEvidence(request) {
+    return classifyRunRequestReplayEvidence(request);
+  }
+  function dropProjectorInput(adapterInputId) {
+    projectorInputDropById.get(adapterInputId)?.();
+    projectorInputDropById.delete(adapterInputId);
+  }
+  function closeRetentionEvidenceHorizon(victim) {
+    const key = retentionEvidenceClosedKey(victim.value.adapterInputId);
+    const sequence = nextRetentionSequence();
+    const entry = retentionEvidenceEntry(key, sequence, {
+      adapterInputId: victim.value.adapterInputId,
+      evidenceKind: victim.value.evidenceKind,
+      occurredAtMs: nowMs(),
+      ...victim.value.attemptHighWater === void 0 ? {} : { attemptHighWater: victim.value.attemptHighWater },
+      reason: victim.value.reason
+    });
+    closedRetentionEvidence.set(key, entry, entry);
+    trimClosedRetentionEvidence();
+  }
+  function trimClosedRetentionEvidence() {
+    const maxSize = effectiveRetention.retentionEvidence?.maxSize;
+    if (maxSize === void 0) return;
+    const victims = closedRetentionEvidence.trimFifo(maxSize);
+    for (const victim of victims) {
+      const firstGlobalClosure = !retentionEvidenceHorizonExceeded;
+      if (firstGlobalClosure) retentionEvidenceHorizonExceeded = true;
+      publishRetentionTrimmed("retentionEvidence", victim.key, victim.entry);
+      if (firstGlobalClosure) {
+        publishRetentionEvidenceGlobalFailClosed(victim);
+      }
+    }
+  }
+  function trimAdapterInputs() {
+    trimRuntimeIndex("adapterInputs", adapterInputs, effectiveRetention.adapterInputs, (victim) => {
+      dropProjectorInput(victim.value.adapterInputId);
+      trackAdapterInputTrimmedEvidence(victim.value.adapterInputId);
+    });
+  }
+  function trimRunRequests() {
+    trimRuntimeIndex("runRequests", runRequests, effectiveRetention.runRequests, (victim) => {
+      victim.value.dropKey?.();
+    });
+  }
+  function trimExecutions() {
+    trimRuntimeIndex("executions", executions, effectiveRetention.executions, (victim) => {
+      trackExecutionHighWaterEvidence(victim.value.adapterInputId, victim.value.attempt);
+    });
+  }
+  function trimRunStatuses() {
+    trimRuntimeIndex("runStatuses", runStatuses, effectiveRetention.runStatuses, (victim) => {
+      victim.value.dropKey?.();
+    });
+  }
+  function trimRunIssues() {
+    trimRuntimeIndex("runIssues", runIssues, effectiveRetention.runIssues, (victim) => {
+      victim.value.dropKey?.();
+    });
+  }
+  function trimRetentionEvidence() {
+    trimRuntimeIndex(
+      "retentionEvidence",
+      retentionEvidence,
+      effectiveRetention.retentionEvidence,
+      (victim) => {
+        closeRetentionEvidenceHorizon(victim);
+        if (victim.value.evidenceKind === "adapter-input-trimmed") {
+          trimmedAdapterInputIds.delete(victim.value.adapterInputId);
+        } else {
+          executionHighWaterByInput.delete(victim.value.adapterInputId);
+        }
+        adapterInputs.delete(victim.value.adapterInputId);
+        dropProjectorInput(victim.value.adapterInputId);
+      }
+    );
+  }
+  function trimAllRetentionIndexes() {
+    trimAdapterInputs();
+    trimRunRequests();
+    trimExecutions();
+    trimRunStatuses();
+    trimRunIssues();
+    trimRetentionEvidence();
+  }
+  function publishRetentionTrimmed(index, key, entry) {
+    const record = isRecord(entry) ? entry : {};
+    const evidenceKind = typeof record.evidenceKind === "string" ? record.evidenceKind : void 0;
+    const code = index === "retentionEvidence" ? "tool-provider-adapter-runtime-retention-evidence-trimmed" : "tool-provider-adapter-runtime-retention-trimmed";
+    const issue = dataIssue(
+      code,
+      index === "retentionEvidence" ? "Tool provider adapter runtime retention trimmed replay proof evidence and closed the affected horizon." : "Tool provider adapter runtime retention trimmed a runtime-private index entry.",
+      {
+        subjectId: typeof record.adapterInputId === "string" ? record.adapterInputId : typeof record.key === "string" ? runtimeDiagnosticKey(record.key) : index,
+        refs: runtimeEvidenceSourceRefs(index),
+        details: runtimeEvidenceMetadata(index, { key }),
+        severity: "info"
+      }
+    );
+    publishIssue(issue, false);
+    const sourceRefs = runtimeEvidenceSourceRefs(index);
+    const metadata = runtimeEvidenceMetadata(index, {
+      key,
+      extra: evidenceKind === void 0 ? {} : { evidenceKind }
+    });
+    publishRuntimeStatus({
+      status: "retention-trimmed",
+      index,
+      key,
+      ...typeof record.adapterInputId === "string" ? { adapterInputId: record.adapterInputId } : {},
+      ...typeof record.runId === "string" ? { runId: record.runId } : {},
+      ...typeof record.attempt === "number" ? { attempt: record.attempt } : {},
+      issueCode: issue.code,
+      sourceRefs,
+      metadata
+    });
+    publishRuntimeAudit("tool-provider-adapter-runtime-retention-trimmed", {
+      subjectId: issue.subjectId,
+      sourceRefs,
+      issueCode: issue.code,
+      metadata
+    });
+  }
+  function publishRetentionScoreInvalid(index, reason) {
+    const issue = dataIssue(
+      "tool-provider-adapter-retention-score-invalid",
+      "Tool provider adapter runtime retention scorer returned invalid material; last-known-good policy remains active.",
+      {
+        subjectId: index,
+        refs: runtimeEvidenceSourceRefs(index),
+        details: runtimeEvidenceMetadata(index, { extra: { reason } }),
+        severity: "warning"
+      }
+    );
+    publishIssue(issue, index !== "runIssues");
+    const sourceRefs = runtimeEvidenceSourceRefs(index);
+    const metadata = runtimeEvidenceMetadata(index, { extra: { reason } });
+    publishRuntimeStatus({
+      status: "invalid-retention-policy",
+      index,
+      issueCode: issue.code,
+      sourceRefs,
+      metadata
+    });
+    publishRuntimeAudit("tool-provider-adapter-runtime-invalid-retention-policy", {
+      subjectId: index,
+      sourceRefs,
+      issueCode: issue.code,
+      metadata
+    });
+  }
+  function applyRetentionPolicyFact(fact) {
+    const invalidIndexes = /* @__PURE__ */ new Set();
+    if (fact.issues !== void 0 && fact.issues.length > 0) {
+      for (const issue of fact.issues) {
+        publishIssue(issue);
+        const index = toolProviderAdapterRuntimeRetentionIndex(issue.subjectId);
+        if (index !== void 0) invalidIndexes.add(index);
+        publishRuntimeStatus({
+          status: "invalid-retention-policy",
+          ...index === void 0 ? {} : { index },
+          issueCode: issue.code,
+          ...index === void 0 ? {} : { sourceRefs: runtimeEvidenceSourceRefs(index) }
+        });
+        publishRuntimeAudit("tool-provider-adapter-runtime-invalid-retention-policy", {
+          ...issue.subjectId === void 0 ? {} : { subjectId: issue.subjectId },
+          ...index === void 0 ? {} : { sourceRefs: runtimeEvidenceSourceRefs(index) },
+          issueCode: issue.code
+        });
+      }
+    }
+    const adapterInputsPolicy = fact.policies.get("adapterInputs");
+    const runRequestsPolicy = fact.policies.get("runRequests");
+    const executionsPolicy = fact.policies.get("executions");
+    const runStatusesPolicy = fact.policies.get("runStatuses");
+    const runIssuesPolicy = fact.policies.get("runIssues");
+    const retentionEvidencePolicy = fact.policies.get("retentionEvidence");
+    effectiveRetention = {
+      ...invalidIndexes.has("adapterInputs") ? effectiveRetention.adapterInputs === void 0 ? {} : { adapterInputs: effectiveRetention.adapterInputs } : adapterInputsPolicy === void 0 ? {} : { adapterInputs: adapterInputsPolicy },
+      ...invalidIndexes.has("runRequests") ? effectiveRetention.runRequests === void 0 ? {} : { runRequests: effectiveRetention.runRequests } : runRequestsPolicy === void 0 ? {} : { runRequests: runRequestsPolicy },
+      ...invalidIndexes.has("executions") ? effectiveRetention.executions === void 0 ? {} : { executions: effectiveRetention.executions } : executionsPolicy === void 0 ? {} : { executions: executionsPolicy },
+      ...invalidIndexes.has("runStatuses") ? effectiveRetention.runStatuses === void 0 ? {} : { runStatuses: effectiveRetention.runStatuses } : runStatusesPolicy === void 0 ? {} : { runStatuses: runStatusesPolicy },
+      ...invalidIndexes.has("runIssues") ? effectiveRetention.runIssues === void 0 ? {} : { runIssues: effectiveRetention.runIssues } : runIssuesPolicy === void 0 ? {} : { runIssues: runIssuesPolicy },
+      ...invalidIndexes.has("retentionEvidence") ? effectiveRetention.retentionEvidence === void 0 ? {} : { retentionEvidence: effectiveRetention.retentionEvidence } : retentionEvidencePolicy === void 0 ? {} : { retentionEvidence: retentionEvidencePolicy }
+    };
+    trimAllRetentionIndexes();
+  }
+  function publishStatus(input, nextStatus, statusIssues) {
+    if (input.effectRunId === void 0) return;
+    const metadata = sanitizeGraphVisibleRecord({
+      adapterInputId: input.adapterInputId,
+      providerId: input.providerId,
+      toolName: input.toolName
+    });
+    status.down([
+      [
+        "DATA",
+        {
+          kind: "status",
+          requestId: input.requestId,
+          operationId: input.operationId,
+          effectRunId: input.effectRunId,
+          status: nextStatus,
+          sourceRefs: defaultToolProviderAdapterEvidenceRefs(input),
+          ...statusIssues === void 0 ? {} : { issues: statusIssues },
+          ...metadata === void 0 ? {} : { metadata }
+        }
+      ]
+    ]);
+  }
+  function publishAudit(input, kind, metadata, issueCode) {
+    auditSeq += 1;
+    const cleanMetadata = sanitizeGraphVisibleRecord({
+      adapterInputId: input.adapterInputId,
+      providerId: input.providerId,
+      toolName: input.toolName,
+      ...metadata
+    });
+    audit.down([
+      [
+        "DATA",
+        {
+          id: `${name}:audit:${auditSeq}`,
+          kind,
+          subjectId: input.requestId,
+          sourceRefs: defaultToolProviderAdapterEvidenceRefs(input),
+          ...issueCode === void 0 ? {} : { issueCode },
+          ...cleanMetadata === void 0 ? {} : { metadata: cleanMetadata }
+        }
+      ]
+    ]);
+  }
+  function publishOutcome(input, result, request) {
+    if (disposed) return;
+    let outcome;
+    try {
+      outcome = buildToolProviderExecutorOutcome(input, result, {
+        attempt: request.attempt,
+        runId: request.runId,
+        occurredAtMs: opts.now?.(),
+        publicText: opts.publicText
+      });
+    } catch (error) {
+      const issue = adapterRuntimeIssue(
+        input,
+        "tool-provider-adapter-runtime-invalid-input",
+        error
+      );
+      publishIssue(issue);
+      publishRunStatus(request, "failure", [issue]);
+      publishStatus(input, "failed", [issue]);
+      publishAudit(input, "tool-provider-adapter-runtime-invalid-input", void 0, issue.code);
+      return;
+    }
+    outcomes.down([["DATA", outcome]]);
+    const execution = executions.get(executionCoordinate(request));
+    if (execution !== void 0) {
+      executions.set(
+        execution.key,
+        executionRetentionEntry(
+          execution.key,
+          execution.entry.sequence,
+          request,
+          outcome.kind,
+          outcome.occurredAtMs,
+          outcome.outcomeId
+        ),
+        request
+      );
+    }
+    const publishedIssueKeys = /* @__PURE__ */ new Set();
+    for (const issue of outcome.issues ?? []) {
+      publishedIssueKeys.add(`${issue.code}:${issue.message}`);
+      publishIssue(issue);
+    }
+    if (outcome.kind === "failure" && !publishedIssueKeys.has(`${outcome.error.code}:${outcome.error.message}`)) {
+      publishIssue(outcome.error);
+    }
+    const statusIssues = outcomeIssues(outcome);
+    publishStatus(
+      input,
+      agentRequestStatusForExecutorOutcome(outcome),
+      statusIssues.length === 0 ? void 0 : statusIssues
+    );
+    publishRunStatus(
+      request,
+      outcome.kind,
+      statusIssues.length === 0 ? void 0 : statusIssues,
+      outcome.outcomeId
+    );
+    publishAudit(input, "tool-provider-adapter-runtime-finished", {
+      status: outcome.kind,
+      outcomeId: outcome.outcomeId,
+      runId: request.runId,
+      attempt: request.attempt
+    });
+  }
+  function publishRuntimeFailure(input, request, code, error) {
+    const issue = adapterRuntimeIssue(input, code, error);
+    publishOutcome(
+      input,
+      {
+        kind: "failure",
+        error: issue,
+        retryable: false,
+        issues: [issue]
+      },
+      request
+    );
+  }
+  function executionCoordinate(request) {
+    return `${request.adapterInputId}:${request.attempt}`;
+  }
+  function trackRunRequest(request, emittedKey, dropKey) {
+    const sequence = nextRetentionSequence();
+    runRequests.set(emittedKey, runRequestRetentionEntry(emittedKey, sequence, request), {
+      fact: request,
+      dropKey
+    });
+    trimRunRequests();
+  }
+  function startExecutionProof(request) {
+    const coordinate = executionCoordinate(request);
+    const existing = executions.get(coordinate);
+    if (existing !== void 0) {
+      if (existing.value.runId !== request.runId) {
+        const issue = dataIssue(
+          "tool-provider-adapter-runtime-duplicate-execution-coordinate",
+          "Tool provider adapter runtime requires one visible runId per adapterInputId and attempt.",
+          {
+            subjectId: request.adapterInputId,
+            refs: [ref("tool-provider-adapter-run", request.runId)],
+            details: {
+              adapterInputId: request.adapterInputId,
+              attempt: request.attempt
+            }
+          }
+        );
+        publishIssue(issue);
+        publishRunStatus(request, "mismatched-request", [issue]);
+        publishRuntimeAudit("tool-provider-adapter-runtime-duplicate-execution-coordinate", {
+          subjectId: request.adapterInputId,
+          sourceRefs: [ref("tool-provider-adapter-run", request.runId)],
+          issueCode: issue.code,
+          metadata: {
+            adapterInputId: request.adapterInputId,
+            attempt: request.attempt,
+            key: runtimeDiagnosticKey(coordinate)
+          }
+        });
+      }
+      return false;
+    }
+    const sequence = nextRetentionSequence();
+    executions.set(
+      coordinate,
+      executionRetentionEntry(coordinate, sequence, request, "started", nowMs()),
+      request
+    );
+    trimExecutions();
+    const classification = classifyRunRequestReplayEvidence(
+      request,
+      adapterInputs.get(request.adapterInputId)?.value
+    );
+    if (classification.kind !== "fresh") {
+      executions.delete(coordinate);
+      publishReplayClassification(request, classification);
+      return false;
+    }
+    return true;
+  }
+  function publishReplayClassification(request, classification) {
+    if (classification.kind === "fresh") return false;
+    if (classification.kind === "missing-input") {
+      const issueCode = "tool-provider-adapter-runtime-missing-input";
+      const issue = dataIssue(
+        issueCode,
+        "Tool provider adapter runtime requires the requested adapter input.",
+        {
+          subjectId: request.adapterInputId,
+          refs: [ref("tool-provider-adapter-run", request.runId)],
+          details: {
+            adapterInputId: request.adapterInputId,
+            runId: request.runId,
+            attempt: request.attempt,
+            issueCode
+          }
+        }
+      );
+      publishIssue(issue);
+      publishRunStatus(request, "missing-input", [issue]);
+      return true;
+    }
+    publishRetentionGap(request, classification);
+    return true;
+  }
+  function publishRetentionGap(request, classification) {
+    publishAdapterRuntimeRetentionGap(
+      { publishIssue, publishRunStatus, publishRuntimeStatus, publishRuntimeAudit },
+      request,
+      classification
+    );
+  }
+  function publishRetentionEvidenceGlobalFailClosed(victim) {
+    publishAdapterRuntimeRetentionEvidenceGlobalFailClosed(
+      { publishIssue, publishRunStatus, publishRuntimeStatus, publishRuntimeAudit },
+      victim
+    );
+  }
+  function runRequest(request) {
+    runAdapterRuntimeRequest(
+      {
+        isDisposed: () => disposed,
+        adapterInputs,
+        executions,
+        bindings,
+        now: opts.now,
+        classifyRunRequestReplayEvidence,
+        publishReplayClassification,
+        startExecutionProof,
+        executionCoordinate,
+        publishIssue,
+        publishRunStatus,
+        publishStatus,
+        publishAudit,
+        publishOutcome,
+        publishRuntimeFailure
+      },
+      request
+    );
+  }
+  const unsubscribeRetentionPolicy = retentionPolicy.subscribe((msg) => {
+    if (msg[0] === "DATA") applyRetentionPolicyFact(msg[1]);
+  });
+  const unsubscribeInputs = opts.inputs.subscribe((msg) => {
+    if (msg[0] !== "DATA") return;
+    const input = msg[1];
+    if (isRetentionEvidenceClosed(input.adapterInputId)) {
+      adapterInputs.delete(input.adapterInputId);
+      dropProjectorInput(input.adapterInputId);
+      return;
+    }
+    if (trimmedAdapterInputIds.delete(input.adapterInputId)) {
+      retentionEvidence.delete(`adapter-input-trimmed:${input.adapterInputId}`);
+    }
+    const sequence = nextRetentionSequence();
+    adapterInputs.set(
+      input.adapterInputId,
+      adapterInputRetentionEntry(input.adapterInputId, sequence, input, nowMs()),
+      input
+    );
+    trimAdapterInputs();
+  });
+  const runProjector = toolProviderAdapterRunProjectorInternal(graph, {
+    name: `${name}/runs`,
+    inputs: opts.inputs,
+    runRequests: opts.runRequests,
+    autoRunReadyInputs: opts.autoRunReadyInputs,
+    now: opts.now,
+    publicText: opts.publicText,
+    privateRetentionHooks: {
+      onRunRequestKey(entry) {
+        trackRunRequest(entry.request, entry.key, entry.dropKey);
+      },
+      onRunStatusKey(entry) {
+        trackRunStatus(entry.status, entry.key, entry.dropKey);
+      },
+      onRunIssueKey(entry) {
+        trackRunIssue(entry.issue, entry.key, entry.dropKey);
+      },
+      onAdapterInputKey(entry) {
+        if (isRetentionEvidenceClosed(entry.adapterInputId) || !adapterInputs.has(entry.adapterInputId)) {
+          entry.dropInput();
+          projectorInputDropById.delete(entry.adapterInputId);
+          return;
+        }
+        projectorInputDropById.set(entry.adapterInputId, entry.dropInput);
+      },
+      classifyRetainedRunRequestReplayEvidence
+    }
+  });
+  const unsubscribeRunProjectorStatus = runProjector.status.subscribe((msg) => {
+    if (msg[0] === "DATA") {
+      const statusFact = msg[1];
+      runStatus.down([["DATA", statusFact]]);
+    }
+  });
+  const unsubscribeRunProjectorIssues = runProjector.issues.subscribe((msg) => {
+    if (msg[0] === "DATA") publishIssue(msg[1], false);
+  });
+  const unsubscribeRunProjectorAudit = runProjector.audit.subscribe((msg) => {
+    if (msg[0] === "DATA") audit.down([["DATA", msg[1]]]);
+  });
+  const unsubscribeRunRequests = runProjector.requests.subscribe((msg) => {
+    if (msg[0] !== "DATA") return;
+    const request = msg[1];
+    runRequest(request);
+  });
+  return {
+    runRequests: runProjector.requests,
+    runStatus,
+    runtimeStatus,
+    outcomes,
+    status,
+    issues,
+    audit,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      unsubscribeRetentionPolicy();
+      unsubscribeInputs();
+      unsubscribeRunProjectorStatus();
+      unsubscribeRunProjectorIssues();
+      unsubscribeRunProjectorAudit();
+      unsubscribeRunRequests();
+    }
+  };
+}
+
+export {
+  attachToolProviderAdapterRuntime
+};
+//# sourceMappingURL=chunk-WOS7RJYZ.js.map