@tangle-network/agent-runtime 0.89.0 → 0.90.1

package/dist/{chunk-BQPFZE2C.js → chunk-WRUSWK4F.js}

@@ -5,13 +5,13 @@ import {
   definePersona,
   runPersonified,
   worktreeFanout
-} from "./chunk-PIPPLSOF.js";
-import {
-  createExecutorRegistry
-} from "./chunk-N7EJV7N3.js";
+} from "./chunk-ZV4LXYCJ.js";
 import {
   runAnalystLoop
 } from "./chunk-ZQZX77MM.js";
+import {
+  createExecutorRegistry
+} from "./chunk-RYBVU4M3.js";
 import {
   ConfigError
 } from "./chunk-YEJR7IXO.js";
@@ -196,4 +196,4 @@ export {
   runLoopRunnerCli,
   parseLoopRunnerArgv
 };
-//# sourceMappingURL=chunk-BQPFZE2C.js.map
+//# sourceMappingURL=chunk-WRUSWK4F.js.map

package/dist/{chunk-PIPPLSOF.js → chunk-ZV4LXYCJ.js}

@@ -15,7 +15,7 @@ import {
   settledToIteration,
   supervise,
   withDriverExecutor
-} from "./chunk-N7EJV7N3.js";
+} from "./chunk-RYBVU4M3.js";
 import {
   addTokenUsage,
   isAbortError,
@@ -2738,20 +2738,29 @@ async function consultAnalyst(task, messages, instruction, opts) {
   const trajectory = compactTrajectory(messages);
   const analystModel = opts.analystModel ?? opts.model;
   const chat = analystChat(opts, analystModel);
+  const consultMessages = trajectory ? [
+    { role: "system", content: instruction },
+    {
+      role: "user",
+      content: `TASK: ${task.userPrompt.slice(0, 1500)}
+
+TRAJECTORY:
+${trajectory}`
+    }
+  ] : [
+    {
+      role: "user",
+      content: `${instruction}
+
+TASK:
+${task.userPrompt.slice(0, 1500)}`
+    }
+  ];
   const res = await chat.chat({
     model: analystModel,
     temperature: 0.2,
     maxTokens: 1024,
-    messages: [
-      { role: "system", content: instruction },
-      {
-        role: "user",
-        content: `TASK: ${task.userPrompt.slice(0, 1500)}
-
-TRAJECTORY:
-${trajectory}`
-      }
-    ]
+    messages: consultMessages
   });
   const usage = res.usage;
   return {
@@ -2797,6 +2806,30 @@ async function analyze(task, messages, opts) {
   const steer = obs.findings.map((f) => f.recommended_action).filter((a) => typeof a === "string" && a.trim().length > 0).join("\n").trim();
   return { steer: steer || "COMPLETE", tokens };
 }
+async function renderCorpusReadback(opts) {
+  if (!opts.corpus || !opts.corpusReadback) return "";
+  const maxFacts = opts.corpusReadback.maxFacts ?? 3;
+  if (!Number.isInteger(maxFacts) || maxFacts < 0) {
+    throw new Error(`corpusReadback.maxFacts must be a non-negative integer, got ${maxFacts}`);
+  }
+  if (maxFacts === 0) return "";
+  const tags = [
+    ...opts.corpusTags ?? [],
+    ...opts.corpusReadback.tags ?? [],
+    ...opts.corpusReadback.includeOperatorFacts ? [] : ["audience:agent"]
+  ];
+  const facts = await opts.corpus.query({
+    ...tags.length > 0 ? { tags } : {},
+    minConfidence: opts.corpusReadback.minConfidence ?? 0.7,
+    limit: maxFacts
+  });
+  if (facts.length === 0) return "";
+  const rendered = facts.map(
+    (fact) => fact.rationale ? `- ${fact.claim} (${fact.rationale})` : `- ${fact.claim}`
+  );
+  return `Relevant learned facts from prior attempts:
+${rendered.join("\n")}`;
+}
 function shotExecutor(surface, opts) {
   let artifact;
   return {
@@ -2941,7 +2974,8 @@ function depthStrategy(surface, task, opts, cfg) {
       try {
         for (shots = 0; shots < cfg.maxShots; shots += 1) {
           const child = leaf(`shot:${shots}`, "shot");
-          const steer = shots === 0 ? void 0 : pendingSteer;
+          const memorySteer = await renderCorpusReadback(opts);
+          const steer = [shots === 0 ? void 0 : pendingSteer, memorySteer].filter((part) => typeof part === "string" && part.trim().length > 0).join("\n\n");
           const res = scope.spawn(child, { task, handle, messages, steer }, {
             budget: perChild(innerTurns),
             label: `shot:${shots}`
@@ -3536,6 +3570,11 @@ async function openSandboxRun(client, options, deliverable) {
           options.promptOptions
         );
         handle = r.handle;
+        await options.beforeStart?.({
+          box: handle.box,
+          sessionId: handle.sessionId,
+          signal: options.signal
+        });
         const result = await settle2(handle.box, r.events);
         turnCount += 1;
         emit({
@@ -4999,6 +5038,381 @@ function deriveTurnSignal(callerSignal, timeoutMs) {
   };
 }
 
+// src/runtime/structural-rollout.ts
+import { randomBytes } from "crypto";
+var defaultStructuralRolloutPolicy = {
+  k: 5,
+  repairRounds: 2,
+  testgen: 6
+};
+function resolvePolicy(overrides) {
+  const policy = { ...defaultStructuralRolloutPolicy, ...overrides };
+  if (!Number.isInteger(policy.k) || policy.k < 1) {
+    throw new Error(`structuralRollout: policy.k must be an integer >= 1, got ${policy.k}`);
+  }
+  if (!Number.isInteger(policy.repairRounds) || policy.repairRounds < 0) {
+    throw new Error(
+      `structuralRollout: policy.repairRounds must be an integer >= 0, got ${policy.repairRounds}`
+    );
+  }
+  if (!Number.isInteger(policy.testgen) || policy.testgen < 0) {
+    throw new Error(
+      `structuralRollout: policy.testgen must be an integer >= 0, got ${policy.testgen}`
+    );
+  }
+  return policy;
+}
+var authorInstruction = (count, entry) => `Read the task below. Write exactly ${count} single-line assert statements that test the function \`${entry}\`, based ONLY on the behavior the task itself describes. Each assert must be one physical line of the form \`assert ${entry}(...) == expected\` (or a True/False check). Do NOT implement the function. Do NOT copy shown examples verbatim if you can test other cases too. Output ONLY the assert lines inside a single \`\`\`python code block.`;
+function filterAuthoredAsserts(reply, entrySymbol, count) {
+  const fences = [...reply.matchAll(/```(?:python|py)?\s*\n([\s\S]*?)```/gi)].map(
+    (m) => (m[1] ?? "").trim()
+  );
+  const block = fences.length > 0 ? fences.join("\n") : reply;
+  const balanced = (s) => {
+    let d = 0;
+    for (const ch of s) {
+      if (ch === "(" || ch === "[" || ch === "{") d += 1;
+      else if (ch === ")" || ch === "]" || ch === "}") d -= 1;
+      if (d < 0) return false;
+    }
+    return d === 0;
+  };
+  return block.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("assert ") && l.includes(entrySymbol) && balanced(l)).slice(0, count);
+}
+function modelAuthoredChecks(overrides = {}) {
+  return {
+    async generate(_task, ctx) {
+      const count = overrides.count ?? ctx.count;
+      if (count <= 0 || !ctx.entrySymbol) return [];
+      const entry = ctx.entrySymbol;
+      const reply = await ctx.consult(authorInstruction(count, entry));
+      if (!reply) return [];
+      return filterAuthoredAsserts(reply, entry, count).map((code) => ({
+        code,
+        kind: "authored"
+      }));
+    }
+  };
+}
+function officialChecksFromMeta(key = "visibleChecks") {
+  return {
+    async generate(task) {
+      const raw = task.meta?.[key];
+      if (!Array.isArray(raw)) return [];
+      return raw.filter((c) => typeof c === "string" && c.trim().length > 0).map((code) => ({ code, kind: "official" }));
+    }
+  };
+}
+function composeCheckSources(...sources) {
+  return {
+    async generate(task, ctx) {
+      const all = [];
+      for (const source of sources) all.push(...await source.generate(task, ctx));
+      return all;
+    }
+  };
+}
+function resolveEntrySymbol(task) {
+  const meta = task.meta?.entryPoint;
+  if (typeof meta === "string" && meta.trim().length > 0) return meta.trim();
+  const defs = [...task.userPrompt.matchAll(/(?:^|\n)\s*def\s+([A-Za-z_]\w*)\s*\(/g)];
+  const last = defs[defs.length - 1];
+  return last?.[1];
+}
+function buildCheckProgram(candidate, official, authored, nonce) {
+  const officialB64 = Buffer.from(JSON.stringify(official), "utf8").toString("base64");
+  const authoredB64 = Buffer.from(JSON.stringify(authored), "utf8").toString("base64");
+  return `${candidate}
+
+import base64 as _b64, json as _json, sys as _sys
+_official = _json.loads(_b64.b64decode("${officialB64}").decode("utf8"))
+_authored = _json.loads(_b64.b64decode("${authoredB64}").decode("utf8"))
+_lines = []
+def _run(_tests):
+    _att, _fail = 0, 0
+    for _t in _tests:
+        _att += 1
+        try:
+            exec(_t, dict(globals()))
+        except Exception as _e:
+            _fail += 1
+            _lines.append("CHECK FAILED: %s -> %s: %s" % (_t.strip()[:200], type(_e).__name__, str(_e)[:200]))
+    return _att, _fail
+_o_att, _o_fail = _run(_official)
+_a_att, _a_fail = _run(_authored)
+print("SRCK-${nonce} official=%d/%d authored=%d/%d" % (_o_att - _o_fail, _o_att, _a_att - _a_fail, _a_att))
+_sys.stdout.write("\\n".join(_lines)[-1500:])
+_sys.exit(0 if (_o_fail + _a_fail) == 0 and (_o_att + _a_att) > 0 else 1)
+`;
+}
+function sandboxCheckRunner(options = {}) {
+  const python = options.python ?? "python3";
+  const timeoutMs = options.timeoutMs ?? 2e4;
+  return {
+    async run(candidate, checks, ctx) {
+      if (checks.length === 0) {
+        return {
+          passedOfficial: 0,
+          totalOfficial: 0,
+          passedAuthored: 0,
+          totalAuthored: 0,
+          failureOutput: ""
+        };
+      }
+      const box = ctx.box ?? options.box;
+      if (!box) {
+        throw new Error(
+          "sandboxCheckRunner: no execution channel \u2014 bind one via sandboxCheckRunner({ box }) or CheckRunContext.box (ValidationCtx.box / a sandbox instance). Refusing to score without executing: a silent 0 would poison selection."
+        );
+      }
+      const nonce = randomBytes(8).toString("hex");
+      const official = checks.filter((c) => c.kind === "official").map((c) => c.code);
+      const authored = checks.filter((c) => c.kind === "authored").map((c) => c.code);
+      const program = buildCheckProgram(candidate, official, authored, nonce);
+      const b64 = Buffer.from(program, "utf8").toString("base64");
+      const r = await box.exec(`printf '%s' '${b64}' | base64 -d | ${python} -`, { timeoutMs });
+      const summary = new RegExp(
+        `SRCK-${nonce} official=(\\d+)/(\\d+) authored=(\\d+)/(\\d+)`
+      ).exec(r.stdout);
+      if (!summary) {
+        const detail = (r.stderr || r.stdout).slice(-1500) || "no output (crashed or timed out before the checks could run)";
+        return {
+          passedOfficial: 0,
+          totalOfficial: 0,
+          passedAuthored: 0,
+          totalAuthored: 0,
+          failureOutput: detail,
+          crashed: true
+        };
+      }
+      const failureOutput = r.stdout.replace(summary[0], "").slice(-1500).trim();
+      return {
+        passedOfficial: Number(summary[1]),
+        totalOfficial: Number(summary[2]),
+        passedAuthored: Number(summary[3]),
+        totalAuthored: Number(summary[4]),
+        failureOutput
+      };
+    }
+  };
+}
+var frac = (passed, total) => total > 0 ? passed / total : 0;
+function compareCheckOutcomes(a, b) {
+  const aCrashed = a.crashed === true;
+  const bCrashed = b.crashed === true;
+  if (aCrashed !== bCrashed) return aCrashed ? -1 : 1;
+  if (aCrashed) return 0;
+  const official = frac(a.passedOfficial, a.totalOfficial) - frac(b.passedOfficial, b.totalOfficial);
+  if (official !== 0) return official;
+  return frac(a.passedAuthored, a.totalAuthored) - frac(b.passedAuthored, b.totalAuthored);
+}
+function visibleCheckScore(o) {
+  if (o.crashed) return -1;
+  return frac(o.passedOfficial, o.totalOfficial) + 1e-3 * frac(o.passedAuthored, o.totalAuthored);
+}
+function selectBestIndex(outcomes) {
+  let best = 0;
+  for (let i = 1; i < outcomes.length; i += 1) {
+    if (compareCheckOutcomes(outcomes[i], outcomes[best]) > 0) {
+      best = i;
+    }
+  }
+  return best;
+}
+function canDisplace(challenger, incumbent) {
+  if (challenger.crashed === true) return false;
+  if (challenger.passedOfficial < incumbent.passedOfficial) return false;
+  return compareCheckOutcomes(challenger, incumbent) > 0;
+}
+var totalChecks = (o) => o.totalOfficial + o.totalAuthored;
+var passesAllChecks = (o) => o.crashed !== true && totalChecks(o) > 0 && o.passedOfficial === o.totalOfficial && o.passedAuthored === o.totalAuthored;
+function defaultExtractCandidate(messages) {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const calls = messages[i]?.tool_calls;
+    if (!calls) continue;
+    for (let j = calls.length - 1; j >= 0; j -= 1) {
+      const call = calls[j];
+      if (call?.function?.name !== "submit_answer") continue;
+      try {
+        const args = JSON.parse(call.function.arguments ?? "{}");
+        if (typeof args.answer === "string" && args.answer.trim()) return args.answer.trim();
+      } catch {
+      }
+    }
+  }
+  const contents = [];
+  for (const m of messages) {
+    if (m.role === "assistant" && typeof m.content === "string" && m.content.trim()) {
+      contents.push(m.content);
+    }
+  }
+  const fencesOf = (text) => [...text.matchAll(/```(?:python|py)?\s*\n([\s\S]*?)```/gi)].map((m) => (m[1] ?? "").trim());
+  for (let i = contents.length - 1; i >= 0; i -= 1) {
+    const fences = fencesOf(contents[i]);
+    for (let j = fences.length - 1; j >= 0; j -= 1) {
+      if (/(^|\n)\s*def\s+\w+/.test(fences[j])) return fences[j];
+    }
+  }
+  for (let i = contents.length - 1; i >= 0; i -= 1) {
+    const fences = fencesOf(contents[i]);
+    if (fences.length > 0) return fences[fences.length - 1];
+  }
+  return (contents[contents.length - 1] ?? "").trim();
+}
+var DIVERSE_LENSES = [
+  "Answer directly and decisively from what you already know. State the single best answer without hedging.",
+  "Decompose the question into the sub-facts it depends on. Establish each sub-fact explicitly, then compose them into the answer.",
+  "Reason from first principles. Ignore the most obvious or popular guess; derive the answer from underlying facts and relationships.",
+  "Name the most plausible WRONG answer and the trap that makes it tempting. Rule it out, then commit to the answer that survives."
+];
+function slotLens(slot) {
+  const lens = DIVERSE_LENSES[slot % DIVERSE_LENSES.length];
+  const tag = slot < DIVERSE_LENSES.length ? "" : ` (variant ${Math.floor(slot / DIVERSE_LENSES.length) + 1})`;
+  return `${lens}${tag}`;
+}
+function repairSteer(outcome) {
+  return [
+    "Your latest solution failed some of the task-visible checks.",
+    "Result of running the visible checks against it:",
+    "```",
+    outcome.failureOutput.trim() || "(the code crashed before the checks could run)",
+    "```",
+    "Fix the solution so the visible checks pass. Provide the COMPLETE corrected solution the",
+    "same way you provided the original (same tool or format) \u2014 not a fragment or a diff."
+  ].join("\n");
+}
+function describeOutcome(label, o) {
+  if (o.crashed) return `${label}: crashed before the checks could run`;
+  return `${label}: official ${o.passedOfficial}/${o.totalOfficial}, authored ${o.passedAuthored}/${o.totalAuthored}`;
+}
+function structuralRollout(config = {}) {
+  const policy = resolvePolicy(config.policy);
+  const checkSource = config.checkSource ?? composeCheckSources(officialChecksFromMeta(), modelAuthoredChecks());
+  const checkRunner = config.checkRunner ?? sandboxCheckRunner();
+  const extract = config.extractCandidate ?? defaultExtractCandidate;
+  const inner = defineStrategy(
+    "structuralRollout",
+    async (ctx) => {
+      const { task, shot } = ctx;
+      const progression = [];
+      const receipts = [];
+      let completions = 0;
+      let shots = 0;
+      const consult = async (instruction) => {
+        const reply = await ctx.consult([], instruction);
+        completions += 1;
+        return reply;
+      };
+      const entrySymbol = resolveEntrySymbol(task);
+      const checks = await checkSource.generate(task, {
+        count: policy.testgen,
+        ...entrySymbol ? { entrySymbol } : {},
+        consult
+      });
+      const officialChecks = checks.filter((c) => c.kind === "official").length;
+      const authoredChecks = checks.length - officialChecks;
+      const runCtx = { task, ...config.box ? { box: config.box } : {} };
+      const candidates = [];
+      for (let i = 0; i < policy.k; i += 1) {
+        const out = await shot(policy.diverse ? { steer: slotLens(i) } : void 0);
+        if (!out) break;
+        shots += 1;
+        completions += out.completions;
+        progression.push(out.score);
+        const outcome = await checkRunner.run(extract(out.messages), checks, runCtx);
+        candidates.push({
+          index: candidates.length,
+          messages: out.messages,
+          outcome,
+          shotScore: out.score,
+          shotResolved: out.total > 0 && out.passes === out.total
+        });
+      }
+      if (candidates.length === 0) {
+        return {
+          score: 0,
+          resolved: false,
+          completions,
+          progression,
+          shots,
+          selection: receipts,
+          repairStop: "no-candidates",
+          officialChecks,
+          authoredChecks
+        };
+      }
+      let best = candidates[selectBestIndex(candidates.map((c) => c.outcome))];
+      for (const c of candidates) {
+        receipts.push({
+          candidateIndex: c.index,
+          selected: false,
+          score: visibleCheckScore(c.outcome),
+          reason: describeOutcome("sample", c.outcome),
+          selector: "driver"
+        });
+      }
+      let seq = candidates.length;
+      let repairStop = "already-passing";
+      if (!passesAllChecks(best.outcome)) {
+        if (best.outcome.crashed !== true && totalChecks(best.outcome) === 0) {
+          repairStop = "no-signal";
+        } else {
+          repairStop = "rounds-exhausted";
+          for (let r = 0; r < policy.repairRounds; r += 1) {
+            const out = await shot({ messages: best.messages, steer: repairSteer(best.outcome) });
+            if (!out) break;
+            shots += 1;
+            completions += out.completions;
+            progression.push(out.score);
+            const outcome = await checkRunner.run(extract(out.messages), checks, runCtx);
+            const displaced = canDisplace(outcome, best.outcome);
+            const label = displaced ? "repair (displaced the incumbent)" : outcome.crashed !== true && outcome.passedOfficial < best.outcome.passedOfficial ? "repair (held out: passes fewer official checks than the incumbent)" : "repair (held out: no improvement)";
+            receipts.push({
+              candidateIndex: seq,
+              selected: false,
+              score: visibleCheckScore(outcome),
+              reason: describeOutcome(label, outcome),
+              selector: "driver"
+            });
+            if (displaced) {
+              best = {
+                index: seq,
+                messages: out.messages,
+                outcome,
+                shotScore: out.score,
+                shotResolved: out.total > 0 && out.passes === out.total
+              };
+            }
+            seq += 1;
+            if (passesAllChecks(best.outcome)) {
+              repairStop = "repaired-pass";
+              break;
+            }
+          }
+        }
+      }
+      const winner = receipts.find((r) => r.candidateIndex === best.index);
+      if (winner) winner.selected = true;
+      return {
+        score: best.shotScore,
+        resolved: best.shotResolved,
+        completions,
+        progression,
+        shots,
+        selection: receipts,
+        repairStop,
+        officialChecks,
+        authoredChecks
+      };
+    }
+  );
+  if (policy.temperature === void 0) return inner;
+  return {
+    name: inner.name,
+    driver: (surface, task, opts, budget) => inner.driver(surface, task, { ...opts, temperature: policy.temperature }, budget)
+  };
+}
+
 // src/runtime/supervise/detector-monitor.ts
 import {
   argHash,
@@ -5815,6 +6229,30 @@ export {
   createSandboxPromptBackend,
   createOpenAICompatibleBackend,
   normalizeBackendStreamEvent,
+  defaultAnalystInstruction,
+  observe,
+  renderReport,
+  depthStrategy,
+  breadthStrategy,
+  sample,
+  refine,
+  defineStrategy,
+  adaptiveRefine,
+  sampleThenRefine,
+  runAgentic,
+  defaultStructuralRolloutPolicy,
+  filterAuthoredAsserts,
+  modelAuthoredChecks,
+  officialChecksFromMeta,
+  composeCheckSources,
+  resolveEntrySymbol,
+  sandboxCheckRunner,
+  compareCheckOutcomes,
+  visibleCheckScore,
+  selectBestIndex,
+  canDisplace,
+  defaultExtractCandidate,
+  structuralRollout,
   anytimeReport,
   renderAnytimeTable,
   defaultAuditorInstruction,
@@ -5837,9 +6275,6 @@ export {
   naiveDriver,
   dumbDriver,
   defineLeaderboard,
-  defaultAnalystInstruction,
-  observe,
-  renderReport,
   harvestCorpus,
   inProcessSandboxClient,
   createMcpEnvironment,
@@ -5866,14 +6301,6 @@ export {
   trajectoryReport,
   equalKOnCost,
   promotionGate,
-  depthStrategy,
-  breadthStrategy,
-  sample,
-  refine,
-  defineStrategy,
-  adaptiveRefine,
-  sampleThenRefine,
-  runAgentic,
   runBenchmark,
   printBenchmarkReport,
   SandboxRunAbortError,
@@ -5907,4 +6334,4 @@ export {
   computeFindingId,
   makeFinding2 as makeFinding
 };
-//# sourceMappingURL=chunk-PIPPLSOF.js.map
+//# sourceMappingURL=chunk-ZV4LXYCJ.js.map