@tangle-network/agent-runtime 0.101.1 → 0.102.1

package/dist/chunk-UPWGXKXB.js

@@ -0,0 +1,254 @@
+// src/candidate-execution/protected-redaction.ts
+import { createHmac, randomBytes } from "crypto";
+import {
+  DEFAULT_REDACTION_RULES,
+  REDACTION_VERSION,
+  redactString
+} from "@tangle-network/agent-eval";
+function createProtectedRecordRedactor(protectedValues) {
+  const identityKey = randomBytes(32);
+  const aggregate = {
+    version: REDACTION_VERSION,
+    redactionCount: 0,
+    byRule: {}
+  };
+  const mergeReport = (report) => {
+    aggregate.version = report.version;
+    aggregate.redactionCount += report.redactionCount;
+    for (const [rule, count] of Object.entries(report.byRule)) {
+      aggregate.byRule[rule] = (aggregate.byRule[rule] ?? 0) + count;
+    }
+  };
+  const redactScalar = (value, record) => {
+    const redacted = redactProtectedValue(value, protectedValues);
+    if (record) mergeReport(redacted.report);
+    return redacted.value;
+  };
+  const identifier = (value, record) => {
+    const redacted = redactScalar(value, record);
+    if (redacted === value) return value;
+    const digest = createHmac("sha256", identityKey).update(value).digest("hex");
+    return `${redacted}:hmac-sha256:${digest}`;
+  };
+  const transform = (value, record) => {
+    const transformed = transformProtectedRecord(
+      value,
+      void 0,
+      record,
+      redactScalar,
+      identifier
+    );
+    assertNoProtectedEvidence(transformed, protectedValues);
+    return transformed;
+  };
+  return Object.freeze({
+    record: (value) => transform(value, true),
+    query: (value) => transform(value, false),
+    identifier: (value) => identifier(value, false),
+    traceIdentity: (trace) => transform(trace, false),
+    report: () => ({
+      version: aggregate.version,
+      redactionCount: aggregate.redactionCount,
+      byRule: { ...aggregate.byRule }
+    })
+  });
+}
+function redactProtectedValue(value, protectedValues) {
+  const report = {
+    version: REDACTION_VERSION,
+    redactionCount: 0,
+    byRule: {}
+  };
+  const rules = protectedRedactionRules(protectedValues);
+  const redacted = redactNode(value, protectedValues, rules, report);
+  assertNoProtectedEvidence(redacted, protectedValues);
+  return { value: redacted, report };
+}
+function redactProtectedReason(reason, protectedValues) {
+  try {
+    return redactProtectedValue(reason, protectedValues).value;
+  } catch {
+    return "candidate execution failed with a protected error";
+  }
+}
+function assertNoProtectedEvidence(value, protectedValues) {
+  if (value instanceof Uint8Array) {
+    assertNoProtectedBytes(value, protectedValues);
+    return;
+  }
+  if (typeof value === "string") {
+    for (const protectedValue of protectedValueVariants(protectedValues)) {
+      if (value.includes(protectedValue)) {
+        throw new Error("protected value survived candidate evidence redaction");
+      }
+    }
+    if (decodedBase64ContainsProtectedValue(value, protectedValues)) {
+      throw new Error("base64 protected value survived candidate evidence redaction");
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) assertNoProtectedEvidence(entry, protectedValues);
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const [key, entry] of Object.entries(value)) {
+      assertNoProtectedEvidence(key, protectedValues);
+      assertNoProtectedEvidence(entry, protectedValues);
+    }
+  }
+}
+function assertNoProtectedBytes(bytes, protectedValues) {
+  if (containsProtectedBytes(bytes, protectedValues)) {
+    throw new Error("protected value survived candidate evidence byte redaction");
+  }
+}
+function redactNode(value, protectedValues, rules, report) {
+  if (value instanceof Uint8Array) {
+    if (containsProtectedBytes(value, protectedValues)) {
+      recordRedaction(report, "candidate-access-binary", 1);
+      return Uint8Array.from(Buffer.from("[redacted:candidate-access-binary]", "utf8"));
+    }
+    return Uint8Array.from(value);
+  }
+  if (typeof value === "string") {
+    if (decodedBase64ContainsProtectedValue(value, protectedValues)) {
+      recordRedaction(report, "candidate-access-binary", 1);
+      return "[redacted:candidate-access-binary]";
+    }
+    const redacted = redactString(value, [...rules]);
+    for (const [rule, count] of Object.entries(redacted.report.byRule)) {
+      recordRedaction(report, rule, count);
+    }
+    return redacted.output;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => redactNode(entry, protectedValues, rules, report));
+  }
+  if (value && typeof value === "object") {
+    const entries = [];
+    const seenKeys = /* @__PURE__ */ new Set();
+    for (const [key, entry] of Object.entries(value)) {
+      const redactedKey = redactNode(key, protectedValues, rules, report);
+      if (typeof redactedKey !== "string" || seenKeys.has(redactedKey)) {
+        throw new Error("protected evidence redaction produced an ambiguous object key");
+      }
+      seenKeys.add(redactedKey);
+      entries.push([redactedKey, redactNode(entry, protectedValues, rules, report)]);
+    }
+    return Object.fromEntries(entries);
+  }
+  return value;
+}
+function transformProtectedRecord(value, fieldName, record, redactScalar, redactIdentifier) {
+  if (value instanceof Uint8Array) return redactScalar(value, record);
+  if (typeof value === "string") {
+    return fieldName && isIdentifierFieldName(fieldName) ? redactIdentifier(value, record) : redactScalar(value, record);
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (entry) => transformProtectedRecord(entry, fieldName, record, redactScalar, redactIdentifier)
+    );
+  }
+  if (!value || typeof value !== "object") return value;
+  if (fieldName === "tags") {
+    return transformTagMap(value, record, redactScalar, redactIdentifier);
+  }
+  if (fieldName === "tag") {
+    return transformTagFilter(value, record, redactScalar, redactIdentifier);
+  }
+  const entries = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  for (const [key, entry] of Object.entries(value)) {
+    const redactedKey = redactScalar(key, record);
+    if (seenKeys.has(redactedKey)) {
+      throw new Error("protected evidence redaction produced an ambiguous object key");
+    }
+    seenKeys.add(redactedKey);
+    entries.push([
+      redactedKey,
+      transformProtectedRecord(entry, key, record, redactScalar, redactIdentifier)
+    ]);
+  }
+  return Object.fromEntries(entries);
+}
+function transformTagMap(value, record, redactScalar, redactIdentifier) {
+  const entries = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  for (const [key, entry] of Object.entries(value)) {
+    const redactedKey = redactIdentifier(key, record);
+    if (seenKeys.has(redactedKey)) {
+      throw new Error("protected evidence redaction produced an ambiguous trace tag");
+    }
+    seenKeys.add(redactedKey);
+    entries.push([
+      redactedKey,
+      typeof entry === "string" ? redactIdentifier(entry, record) : transformProtectedRecord(entry, key, record, redactScalar, redactIdentifier)
+    ]);
+  }
+  return Object.fromEntries(entries);
+}
+function transformTagFilter(value, record, redactScalar, redactIdentifier) {
+  const output = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const redactedKey = redactScalar(key, record);
+    output[redactedKey] = (key === "key" || key === "value") && typeof entry === "string" ? redactIdentifier(entry, record) : transformProtectedRecord(entry, key, record, redactScalar, redactIdentifier);
+  }
+  return output;
+}
+function isIdentifierFieldName(name) {
+  return /ids?$/i.test(name);
+}
+function protectedRedactionRules(protectedValues) {
+  const exactRules = protectedValueVariants(protectedValues).sort((left, right) => right.length - left.length || left.localeCompare(right)).map((value, index) => ({
+    id: `candidate-access-${index}`,
+    pattern: new RegExp(escapeRegularExpression(value), "g"),
+    replacement: "[redacted:candidate-access]"
+  }));
+  return [...exactRules, ...DEFAULT_REDACTION_RULES];
+}
+function recordRedaction(report, rule, count) {
+  if (count <= 0) return;
+  report.redactionCount += count;
+  report.byRule[rule] = (report.byRule[rule] ?? 0) + count;
+}
+function containsProtectedBytes(bytes, protectedValues) {
+  const source = Buffer.from(bytes);
+  return protectedValueVariants(protectedValues).some(
+    (value) => source.includes(Buffer.from(value, "utf8"))
+  );
+}
+function decodedBase64ContainsProtectedValue(value, protectedValues) {
+  if (value.length < 4 || value.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(value)) {
+    return false;
+  }
+  try {
+    return containsProtectedBytes(Buffer.from(value, "base64"), protectedValues);
+  } catch {
+    return false;
+  }
+}
+function protectedValueVariants(protectedValues) {
+  const variants = /* @__PURE__ */ new Set();
+  for (const value of normalizedProtectedValues(protectedValues)) {
+    variants.add(value);
+    variants.add(Buffer.from(value, "utf8").toString("base64"));
+    variants.add(Buffer.from(value, "utf8").toString("base64url"));
+    variants.add(encodeURIComponent(value));
+  }
+  return [...variants];
+}
+function normalizedProtectedValues(values) {
+  return [...new Set(values.filter((value) => value.length > 0))];
+}
+function escapeRegularExpression(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export {
+  createProtectedRecordRedactor,
+  redactProtectedValue,
+  redactProtectedReason,
+  assertNoProtectedBytes
+};
+//# sourceMappingURL=chunk-UPWGXKXB.js.map

package/dist/chunk-UPWGXKXB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/candidate-execution/protected-redaction.ts"],"sourcesContent":["import { createHmac, randomBytes } from 'node:crypto'\n\nimport {\n  DEFAULT_REDACTION_RULES,\n  REDACTION_VERSION,\n  type RedactionRule,\n  redactString,\n} from '@tangle-network/agent-eval'\n\nexport interface ProtectedRedactionReport {\n  version: string\n  redactionCount: number\n  byRule: Record<string, number>\n}\n\nexport interface ProtectedTraceIdentity {\n  readonly runId: string\n  readonly tags: Readonly<Record<string, string>>\n}\n\nexport interface ProtectedRecordRedactor {\n  record<T>(value: T): T\n  query<T>(value: T): T\n  identifier(value: string): string\n  traceIdentity(trace: ProtectedTraceIdentity): ProtectedTraceIdentity\n  report(): ProtectedRedactionReport\n}\n\n/** Create one execution-local namespace for identifiers changed by redaction. */\nexport function createProtectedRecordRedactor(\n  protectedValues: readonly string[],\n): ProtectedRecordRedactor {\n  const identityKey = randomBytes(32)\n  const aggregate: ProtectedRedactionReport = {\n    version: REDACTION_VERSION,\n    redactionCount: 0,\n    byRule: {},\n  }\n\n  const mergeReport = (report: ProtectedRedactionReport): void => {\n    aggregate.version = report.version\n    aggregate.redactionCount += report.redactionCount\n    for (const [rule, count] of Object.entries(report.byRule)) {\n      aggregate.byRule[rule] = (aggregate.byRule[rule] ?? 0) + count\n    }\n  }\n\n  const redactScalar = <T>(value: T, record: boolean): T => {\n    const redacted = redactProtectedValue(value, protectedValues)\n    if (record) mergeReport(redacted.report)\n    return redacted.value\n  }\n\n  const identifier = (value: string, record: boolean): string => {\n    const redacted = redactScalar(value, record)\n    if (redacted === value) return value\n    const digest = createHmac('sha256', identityKey).update(value).digest('hex')\n    return `${redacted}:hmac-sha256:${digest}`\n  }\n\n  const transform = <T>(value: T, record: boolean): T => {\n    const transformed = transformProtectedRecord(\n      value,\n      undefined,\n      record,\n      redactScalar,\n      identifier,\n    ) as T\n    assertNoProtectedEvidence(transformed, protectedValues)\n    return transformed\n  }\n\n  return Object.freeze({\n    record: <T>(value: T): T => transform(value, true),\n    query: <T>(value: T): T => transform(value, false),\n    identifier: (value: string): string => identifier(value, false),\n    traceIdentity: (trace: ProtectedTraceIdentity): ProtectedTraceIdentity =>\n      transform(trace, false),\n    report: (): ProtectedRedactionReport => ({\n      version: aggregate.version,\n      redactionCount: aggregate.redactionCount,\n      byRule: { ...aggregate.byRule },\n    }),\n  })\n}\n\n/** Redact protected values at the first persistence boundary, including object keys and bytes. */\nexport function redactProtectedValue<T>(\n  value: T,\n  protectedValues: readonly string[],\n): { value: T; report: ProtectedRedactionReport } {\n  const report: ProtectedRedactionReport = {\n    version: REDACTION_VERSION,\n    redactionCount: 0,\n    byRule: {},\n  }\n  const rules = protectedRedactionRules(protectedValues)\n  const redacted = redactNode(value, protectedValues, rules, report) as T\n  assertNoProtectedEvidence(redacted, protectedValues)\n  return { value: redacted, report }\n}\n\nexport function redactProtectedReason(reason: string, protectedValues: readonly string[]): string {\n  try {\n    return redactProtectedValue(reason, protectedValues).value\n  } catch {\n    return 'candidate execution failed with a protected error'\n  }\n}\n\nexport function assertNoProtectedEvidence(\n  value: unknown,\n  protectedValues: readonly string[],\n): void {\n  if (value instanceof Uint8Array) {\n    assertNoProtectedBytes(value, protectedValues)\n    return\n  }\n  if (typeof value === 'string') {\n    for (const protectedValue of protectedValueVariants(protectedValues)) {\n      if (value.includes(protectedValue)) {\n        throw new Error('protected value survived candidate evidence redaction')\n      }\n    }\n    if (decodedBase64ContainsProtectedValue(value, protectedValues)) {\n      throw new Error('base64 protected value survived candidate evidence redaction')\n    }\n    return\n  }\n  if (Array.isArray(value)) {\n    for (const entry of value) assertNoProtectedEvidence(entry, protectedValues)\n    return\n  }\n  if (value && typeof value === 'object') {\n    for (const [key, entry] of Object.entries(value)) {\n      assertNoProtectedEvidence(key, protectedValues)\n      assertNoProtectedEvidence(entry, protectedValues)\n    }\n  }\n}\n\nexport function assertNoProtectedBytes(\n  bytes: Uint8Array,\n  protectedValues: readonly string[],\n): void {\n  if (containsProtectedBytes(bytes, protectedValues)) {\n    throw new Error('protected value survived candidate evidence byte redaction')\n  }\n}\n\nfunction redactNode(\n  value: unknown,\n  protectedValues: readonly string[],\n  rules: readonly RedactionRule[],\n  report: ProtectedRedactionReport,\n): unknown {\n  if (value instanceof Uint8Array) {\n    if (containsProtectedBytes(value, protectedValues)) {\n      recordRedaction(report, 'candidate-access-binary', 1)\n      return Uint8Array.from(Buffer.from('[redacted:candidate-access-binary]', 'utf8'))\n    }\n    return Uint8Array.from(value)\n  }\n  if (typeof value === 'string') {\n    if (decodedBase64ContainsProtectedValue(value, protectedValues)) {\n      recordRedaction(report, 'candidate-access-binary', 1)\n      return '[redacted:candidate-access-binary]'\n    }\n    const redacted = redactString(value, [...rules])\n    for (const [rule, count] of Object.entries(redacted.report.byRule)) {\n      recordRedaction(report, rule, count)\n    }\n    return redacted.output\n  }\n  if (Array.isArray(value)) {\n    return value.map((entry) => redactNode(entry, protectedValues, rules, report))\n  }\n  if (value && typeof value === 'object') {\n    const entries: Array<[string, unknown]> = []\n    const seenKeys = new Set<string>()\n    for (const [key, entry] of Object.entries(value)) {\n      const redactedKey = redactNode(key, protectedValues, rules, report)\n      if (typeof redactedKey !== 'string' || seenKeys.has(redactedKey)) {\n        throw new Error('protected evidence redaction produced an ambiguous object key')\n      }\n      seenKeys.add(redactedKey)\n      entries.push([redactedKey, redactNode(entry, protectedValues, rules, report)])\n    }\n    return Object.fromEntries(entries)\n  }\n  return value\n}\n\nfunction transformProtectedRecord(\n  value: unknown,\n  fieldName: string | undefined,\n  record: boolean,\n  redactScalar: <T>(value: T, record: boolean) => T,\n  redactIdentifier: (value: string, record: boolean) => string,\n): unknown {\n  if (value instanceof Uint8Array) return redactScalar(value, record)\n  if (typeof value === 'string') {\n    return fieldName && isIdentifierFieldName(fieldName)\n      ? redactIdentifier(value, record)\n      : redactScalar(value, record)\n  }\n  if (Array.isArray(value)) {\n    return value.map((entry) =>\n      transformProtectedRecord(entry, fieldName, record, redactScalar, redactIdentifier),\n    )\n  }\n  if (!value || typeof value !== 'object') return value\n\n  if (fieldName === 'tags') {\n    return transformTagMap(value, record, redactScalar, redactIdentifier)\n  }\n  if (fieldName === 'tag') {\n    return transformTagFilter(value, record, redactScalar, redactIdentifier)\n  }\n\n  const entries: Array<[string, unknown]> = []\n  const seenKeys = new Set<string>()\n  for (const [key, entry] of Object.entries(value)) {\n    const redactedKey = redactScalar(key, record)\n    if (seenKeys.has(redactedKey)) {\n      throw new Error('protected evidence redaction produced an ambiguous object key')\n    }\n    seenKeys.add(redactedKey)\n    entries.push([\n      redactedKey,\n      transformProtectedRecord(entry, key, record, redactScalar, redactIdentifier),\n    ])\n  }\n  return Object.fromEntries(entries)\n}\n\nfunction transformTagMap(\n  value: object,\n  record: boolean,\n  redactScalar: <T>(value: T, record: boolean) => T,\n  redactIdentifier: (value: string, record: boolean) => string,\n): Record<string, unknown> {\n  const entries: Array<[string, unknown]> = []\n  const seenKeys = new Set<string>()\n  for (const [key, entry] of Object.entries(value)) {\n    const redactedKey = redactIdentifier(key, record)\n    if (seenKeys.has(redactedKey)) {\n      throw new Error('protected evidence redaction produced an ambiguous trace tag')\n    }\n    seenKeys.add(redactedKey)\n    entries.push([\n      redactedKey,\n      typeof entry === 'string'\n        ? redactIdentifier(entry, record)\n        : transformProtectedRecord(entry, key, record, redactScalar, redactIdentifier),\n    ])\n  }\n  return Object.fromEntries(entries)\n}\n\nfunction transformTagFilter(\n  value: object,\n  record: boolean,\n  redactScalar: <T>(value: T, record: boolean) => T,\n  redactIdentifier: (value: string, record: boolean) => string,\n): Record<string, unknown> {\n  const output: Record<string, unknown> = {}\n  for (const [key, entry] of Object.entries(value)) {\n    const redactedKey = redactScalar(key, record)\n    output[redactedKey] =\n      (key === 'key' || key === 'value') && typeof entry === 'string'\n        ? redactIdentifier(entry, record)\n        : transformProtectedRecord(entry, key, record, redactScalar, redactIdentifier)\n  }\n  return output\n}\n\nfunction isIdentifierFieldName(name: string): boolean {\n  return /ids?$/i.test(name)\n}\n\nfunction protectedRedactionRules(protectedValues: readonly string[]): RedactionRule[] {\n  const exactRules = protectedValueVariants(protectedValues)\n    .sort((left, right) => right.length - left.length || left.localeCompare(right))\n    .map((value, index) => ({\n      id: `candidate-access-${index}`,\n      pattern: new RegExp(escapeRegularExpression(value), 'g'),\n      replacement: '[redacted:candidate-access]',\n    }))\n  return [...exactRules, ...DEFAULT_REDACTION_RULES]\n}\n\nfunction recordRedaction(report: ProtectedRedactionReport, rule: string, count: number): void {\n  if (count <= 0) return\n  report.redactionCount += count\n  report.byRule[rule] = (report.byRule[rule] ?? 0) + count\n}\n\nfunction containsProtectedBytes(bytes: Uint8Array, protectedValues: readonly string[]): boolean {\n  const source = Buffer.from(bytes)\n  return protectedValueVariants(protectedValues).some((value) =>\n    source.includes(Buffer.from(value, 'utf8')),\n  )\n}\n\nfunction decodedBase64ContainsProtectedValue(\n  value: string,\n  protectedValues: readonly string[],\n): boolean {\n  if (value.length < 4 || value.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(value)) {\n    return false\n  }\n  try {\n    return containsProtectedBytes(Buffer.from(value, 'base64'), protectedValues)\n  } catch {\n    return false\n  }\n}\n\nfunction protectedValueVariants(protectedValues: readonly string[]): string[] {\n  const variants = new Set<string>()\n  for (const value of normalizedProtectedValues(protectedValues)) {\n    variants.add(value)\n    variants.add(Buffer.from(value, 'utf8').toString('base64'))\n    variants.add(Buffer.from(value, 'utf8').toString('base64url'))\n    variants.add(encodeURIComponent(value))\n  }\n  return [...variants]\n}\n\nfunction normalizedProtectedValues(values: readonly string[]): string[] {\n  return [...new Set(values.filter((value) => value.length > 0))]\n}\n\nfunction escapeRegularExpression(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n"],"mappings":"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","names":[]}

package/dist/{completion-gate-C80jiRfN.d.ts → completion-gate-C6dhVN-N.d.ts}

@@ -1,6 +1,6 @@
 import { WorkspacePlanReceipt } from '@tangle-network/agent-profile-materialize';
-import { L as LocalHarness, C as CodexTokenUsage, c as CodexExecutionPolicy } from './local-harness-ZqCx51u7.js';
-import { c as Executor } from './types-CmnA2iL3.js';
+import { L as LocalHarness, C as CodexTokenUsage, c as CodexExecutionPolicy } from './local-harness-CtK9dSny.js';
+import { c as Executor } from './types-D870JlH0.js';
 
 /**
  *

package/dist/{coordination-BFE3Den7.d.ts → coordination-D9l_YmwW.d.ts}

@@ -1,13 +1,13 @@
-import { E as ExecutorFactory, e as ExecutorRegistry, i as Spend, A as Agent, S as Scope, a as ResultBlobStore, B as Budget } from './types-CmnA2iL3.js';
+import { E as ExecutorFactory, h as ExecutorRegistry, e as Spend, A as Agent, S as Scope, a as ResultBlobStore, B as Budget } from './types-D870JlH0.js';
 import { AgentProfile } from '@tangle-network/agent-interface';
-import { U as UiLens, a as UiFinding, C as CoderTask } from './substrate-DO2GHNg2.js';
-import { S as SandboxClient, E as ExecCtx, r as LoopTraceEmitter, b as LoopTraceEvent, A as AgentRunSpec } from './types-B3vAW0Oq.js';
+import { a as UiLens, U as UiFinding, C as CoderTask } from './substrate-Dyiqmd3o.js';
+import { S as SandboxClient, E as ExecCtx, d as LoopTraceEmitter, c as LoopTraceEvent, A as AgentRunSpec } from './types-CLat4bT9.js';
 import { BackendType, SandboxEvent, SandboxInstance } from '@tangle-network/sandbox';
 import { AgentEvalError } from '@tangle-network/agent-eval';
-import { b as ToolSpec, c as RuntimeTelemetryOptions, R as RouterConfig } from './sanitize-BTSsdBXw.js';
+import { b as ToolSpec, c as RuntimeTelemetryOptions, R as RouterConfig } from './sanitize-DEbPNtyI.js';
 import { R as RuntimeStreamEvent } from './types-BwoZWq-i.js';
-import { G as GitRunner, a as WorktreeCheckRunner, D as DeliverableSpec } from './completion-gate-C80jiRfN.js';
-import { L as LocalHarness } from './local-harness-ZqCx51u7.js';
+import { G as GitRunner, a as WorktreeCheckRunner, D as DeliverableSpec } from './completion-gate-C6dhVN-N.js';
+import { L as LocalHarness } from './local-harness-CtK9dSny.js';
 import { ProviderExecutorOptions, AgentEnvironmentProviderRegistry } from './environment-provider.js';
 import { AgentEnvironmentProvider } from '@tangle-network/agent-interface/environment-provider';
 

package/dist/environment-provider.d.ts

@@ -2,8 +2,8 @@ import { AgentProfile, AgentProfileValidationResult } from '@tangle-network/agen
 import { CreateAgentEnvironmentInput, AgentTurnInput, AgentEnvironmentProvider, AgentEnvironmentCapabilities, AgentProfileRef } from '@tangle-network/agent-interface/environment-provider';
 export { AgentEnvironment, AgentEnvironmentCapabilities, AgentEnvironmentEvent, AgentEnvironmentProvider, AgentEnvironmentQuery, AgentEnvironmentStatus, AgentEnvironmentSummary, AgentProfileRef, AgentSession, AgentSessionRef, AgentSessionStatus, AgentTurnInput, AgentTurnResult, CheckpointRef, CheckpointRequest, CreateAgentEnvironmentInput, ExecRequest, ExecResult, ForkRequest, PlacementInfo, ResourceRequest, WorkspaceRequest } from '@tangle-network/agent-interface/environment-provider';
 import { CreateSandboxOptions, BackendType } from '@tangle-network/sandbox';
-import { R as Runtime, E as ExecutorFactory } from './types-CmnA2iL3.js';
-import { S as SandboxClient } from './types-B3vAW0Oq.js';
+import { R as Runtime, E as ExecutorFactory } from './types-D870JlH0.js';
+import { S as SandboxClient } from './types-CLat4bT9.js';
 import '@tangle-network/agent-eval';
 import './types-BwoZWq-i.js';
 

package/dist/{improve-g75IE2Cx.d.ts → improve-B40dRu0X.d.ts}

@@ -1,7 +1,7 @@
 import { LabeledScenarioStore, WorktreeAdapter, SurfaceProposer } from '@tangle-network/agent-eval/campaign';
 import { Scenario, SelfImproveOptions, SurfaceProposer as SurfaceProposer$1, MutableSurface, SelfImproveResult } from '@tangle-network/agent-eval/contract';
 import { AgentProfile, ReasoningEffort } from '@tangle-network/agent-interface';
-import { L as LocalHarness, C as CodexTokenUsage, a as CodexExecutionEvidence, b as LocalHarnessResult, r as runLocalHarness } from './local-harness-ZqCx51u7.js';
+import { L as LocalHarness, C as CodexTokenUsage, a as CodexExecutionEvidence, b as LocalHarnessResult, r as runLocalHarness } from './local-harness-CtK9dSny.js';
 import { AnalystFinding, CostLedgerHandle, MaximumCharge } from '@tangle-network/agent-eval';
 
 /**
@@ -66,6 +66,13 @@ interface CandidateGenerator {
     }): Promise<{
         applied: boolean;
         summary: string;
+        /** Short slug for the candidate. When present (with `rationale`), the
+         *  driver returns a `ProposedCandidate` wrapper so the label survives to
+         *  `GenerationRecord` and the emitted provenance. */
+        label?: string;
+        /** Why this change was proposed — bounded, derived from the findings the
+         *  shot addressed. Paired with `label`. */
+        rationale?: string;
     }>;
 }
 interface ImprovementDriverOptions {
@@ -128,7 +135,7 @@ interface VerifyResult {
 /** Verifies the edited worktree. Sync or async; throws only on a setup fault
  *  (a candidate that fails verification returns `{ok:false}`, it does not
  *  throw). */
-type Verifier = (worktreePath: string) => Promise<VerifyResult> | VerifyResult;
+type Verifier = (worktreePath: string, signal?: AbortSignal) => Promise<VerifyResult> | VerifyResult;
 interface AgenticGeneratorShotReceipt {
     readonly generation: number | null;
     readonly candidateIndex: number | null;
@@ -144,6 +151,8 @@ interface AgenticGeneratorShotReceipt {
     readonly durationMs: number;
     readonly exitCode: number | null;
     readonly timedOut: boolean;
+    /** True when caller cancellation reached the author process; absent in older receipts. */
+    readonly aborted?: boolean;
     readonly killedBySignal: NodeJS.Signals | null;
     readonly stdoutBytes: number | null;
     readonly stdoutSha256: `sha256:${string}` | null;
@@ -247,6 +256,12 @@ interface AgenticGeneratorOptions {
 }
 /** Full-agentic `CandidateGenerator` (the `shots=N, sandbox=on` setting): run a real coding harness inside the candidate worktree so the agent makes the change in place. */
 declare function agenticGenerator(opts?: AgenticGeneratorOptions): CandidateGenerator;
+/** Turn the analyst's findings (+ optional report) into a concrete coder task —
+ *  the senior scientific-method framing shared with the tool/MCP build prompts. */
+declare function defaultBuildPrompt(args: {
+    report: unknown;
+    findings: AnalystFinding[];
+}): string;
 /** A `Verifier` that runs a command in the worktree: exit 0 ⇒ ok, any other
  *  exit ⇒ failed with stdout+stderr as feedback. The common case — verify by
  *  `tsc --noEmit`, `pnpm build`, or a test command. A timeout is treated as a
@@ -271,6 +286,11 @@ declare function commandVerifier(command: string, args?: string[], timeoutMs?: n
  *   - `surface: 'skills'` → `skillOptProposer` mutates one named inline skill.
  *   - `surface: 'memory'` → `memoryCurationProposer` curates the profile's
  *     additional instructions as bounded durable lessons.
+ *   - `surface: 'rollout-policy'` → `rolloutPolicyProposer` mutates the
+ *     inference-time `StructuralRolloutPolicy` dials ({ k, repairRounds, testgen })
+ *     persisted in `profile.extensions['structural-rollout']` — deterministic
+ *     bounded neighbor enumeration; the held-out gate does the deciding. No-op
+ *     (nothing proposed, nothing shipped) when the profile has no such extension.
  *   - `surface: 'agent-profile'` → caller-supplied proposer mutates the complete
  *     canonical AgentProfile JSON in one candidate.
  *   - `surface` ∈ {`tools`, `mcp`, `hooks`, `subagents`, `agent-profile`} → no zero-config default
@@ -290,8 +310,10 @@ declare function commandVerifier(command: string, args?: string[], timeoutMs?: n
 
 /** The executable agent lever `improve` optimizes. Profile fields remain
  *  portable AgentProfile coordinates; implementation and orchestration files
- *  use the code surface so a winner can be sealed into an exact candidate. */
-type ImproveSurface = 'prompt' | 'skills' | 'tools' | 'mcp' | 'hooks' | 'subagents' | 'agent-profile' | 'memory' | 'code';
+ *  use the code surface so a winner can be sealed into an exact candidate.
+ *  `rollout-policy` is the inference-time structuralRollout dials
+ *  (`profile.extensions['structural-rollout']`). */
+type ImproveSurface = 'prompt' | 'skills' | 'tools' | 'mcp' | 'hooks' | 'subagents' | 'agent-profile' | 'memory' | 'code' | 'rollout-policy';
 type ImproveOptions<TScenario extends Scenario, TArtifact> = Omit<SelfImproveOptions<TScenario, TArtifact>, 'analyzeGeneration' | 'baselineSurface' | 'findings' | 'gate' | 'proposer'> & {
     /** Which profile lever to optimize. Default `'prompt'`. Selects the default
      *  generator + the baseline-surface extraction shape. */
@@ -309,22 +331,26 @@ type ImproveOptions<TScenario extends Scenario, TArtifact> = Omit<SelfImproveOpt
      *  a `ConfigError` before the generator is built. Unset = unrestricted. */
     allowedModels?: readonly string[];
     /** Per-generation findings producer passthrough (see selfImprove.analyzeGeneration).
-     *  DEFAULT: the built-in failure distiller — after each generation it turns the
-     *  worst-scoring/errored cells into structured findings ({ scenario, composite,
-     *  notes, error }) for the NEXT proposal round, so the proposer reasons over what
-     *  actually failed instead of a static seed. Pass your own producer (e.g. a
-     *  trace-analyst over the runDir's traces) to replace it; pass `null` to disable
-     *  and keep the static `findings` all the way through. */
+     *  DEFAULT: with a real (non-`mem://`) `runDir`, the raw-trace distiller
+     *  (`rawTraceDistiller`) — typed `AnalystFinding`s pointing the proposer at the
+     *  prior generation's actual on-disk traces; for in-memory runs (no traces on
+     *  disk to point at), the built-in failure distiller — the worst-scoring/errored
+     *  cells distilled into typed `AnalystFinding`s for the NEXT proposal round.
+     *  Pass your own producer to replace either; pass `null` to disable and keep the
+     *  static `findings` all the way through. */
     analyzeGeneration?: SelfImproveOptions<TScenario, TArtifact>['analyzeGeneration'] | null;
-    /** META-HARNESS mode: instead of the ~1500-char distilled findings, feed the
-     *  proposer RAW-TRACE FILESYSTEM CONTEXT — the PATHS into the prior generation's
+    /** META-HARNESS mode: instead of the distilled findings, feed the proposer
+     *  RAW-TRACE FILESYSTEM CONTEXT — the PATHS into the prior generation's
      *  real run traces under `runDir` (per-cell `spans.jsonl` event logs +
      *  `cached-result.json` scores + artifacts) plus a `grep`/`cat`-to-diagnose
      *  instruction — so the coding agent reads the actual failures itself rather than
-     *  a pre-summary. Requires a REAL `runDir` (that is where the traces live).
-     *  Ignored when `analyzeGeneration` is set explicitly (that wins) or is `null`
-     *  (disabled). Equivalent to `analyzeGeneration: rawTraceDistiller()`; this flag
-     *  is the one-line enable. Default `false` (the distiller stays the default). */
+     *  a pre-summary. Unset (default): raw-trace findings whenever the run is durable
+     *  (a real `runDir` — that is where the traces live), the distilled failure digest
+     *  otherwise; the `memory` surface always defaults to its curation distiller.
+     *  `true` forces `rawTraceDistiller()` even for an in-memory run (it emits a loud
+     *  warning finding instead of paths); `false` forces the digest distiller even
+     *  with a real `runDir`. Ignored when `analyzeGeneration` is set explicitly
+     *  (that wins) or is `null` (disabled). */
     rawTraceContext?: boolean;
     /** CODE-surface wiring: name `surface: 'code'`, point at a repo, and the
      *  facade assembles the whole candidate pipeline — an isolated incumbent plus git worktrees
@@ -378,8 +404,10 @@ interface ImproveResult<TScenario extends Scenario, TArtifact> {
     candidate: ImprovementCandidate;
     /** Held-out decision for this search result. */
     decision: SelfImproveResult<TScenario, TArtifact>['gateDecision'];
-    /** Held-out lift (`winner − baseline` composite). */
-    lift: number;
+    /** Held-out lift (`winner − baseline` composite). Absent iff
+     *  `budget.holdout === 'deferred'` — no held-out measurement ran, so there
+     *  is no lift to report (never a fabricated 0). */
+    lift?: number;
     /** Full `selfImprove` result for advanced inspection. For code runs,
      *  `raw.winner.surface.worktreeRef` remains live after return whether the
      *  candidate passed or held; call `dispose()` after consuming it. */
@@ -403,4 +431,4 @@ interface ImproveResult<TScenario extends Scenario, TArtifact> {
  */
 declare function improve<TScenario extends Scenario, TArtifact>(profile: AgentProfile, findings: unknown[], opts: ImproveOptions<TScenario, TArtifact>): Promise<ImproveResult<TScenario, TArtifact>>;
 
-export { AGENTIC_PROFILE_RESOURCE_ROOT as A, type CandidateGenerator as C, type ImproveOptions as I, type ManagedImprovementDriver as M, type Verifier as V, type ImproveResult as a, type AgenticGeneratorOptions as b, type AgenticGeneratorShotDisposition as c, type AgenticGeneratorShotExecution as d, type AgenticGeneratorShotReceipt as e, type ImproveCodeOptions as f, type ImproveSkillsOptions as g, type ImproveSurface as h, type ImprovementCandidate as i, type ImprovementDriverOptions as j, type VerifyResult as k, agenticGenerator as l, commandVerifier as m, improve as n, improvementDriver as o };
+export { AGENTIC_PROFILE_RESOURCE_ROOT as A, type CandidateGenerator as C, type ImproveOptions as I, type ManagedImprovementDriver as M, type Verifier as V, type ImproveResult as a, type AgenticGeneratorOptions as b, type AgenticGeneratorShotDisposition as c, type AgenticGeneratorShotExecution as d, type AgenticGeneratorShotReceipt as e, type ImproveCodeOptions as f, type ImproveSkillsOptions as g, type ImproveSurface as h, type ImprovementCandidate as i, type ImprovementDriverOptions as j, type VerifyResult as k, agenticGenerator as l, commandVerifier as m, defaultBuildPrompt as n, improve as o, improvementDriver as p };