@tangle-network/agent-eval 0.122.2 → 0.122.4

package/dist/campaign/index.js

@@ -4,6 +4,7 @@ import {
   FsLabeledScenarioStore,
   LabeledScenarioStoreError,
   Lineage,
+  LineageStoreConflictError,
   ProfileMatrixError,
   SEARCH_LEDGER_SCHEMA,
   SkillPatchParseError,
@@ -15,6 +16,7 @@ import {
   assertPolicyEditAuthorContextBudget,
   buildAnalystSurfaceDispatch,
   callbackGovernor,
+  campaignLineageStore,
   classifyUngroundedLiterals,
   compareProposers,
   compositeProposer,
@@ -66,7 +68,7 @@ import {
   userStoryScoreboard,
   validateSearchLedgerEvent,
   verifyCodeSurface
-} from "../chunk-EXMKNOP5.js";
+} from "../chunk-75OCWDXJ.js";
 import {
   assertCodeSurfaceIdentity,
   buildEvidenceVector,
@@ -107,7 +109,7 @@ import {
   surfaceContentHash,
   surfaceHash,
   verifyLoopProvenanceRecord
-} from "../chunk-U4R2AGY5.js";
+} from "../chunk-MWN2X7C5.js";
 import {
   SearchLedgerConflictError,
   SearchLedgerError,
@@ -124,12 +126,11 @@ import {
   resolveRunDir,
   runCampaign,
   tangleTracesRoot
-} from "../chunk-N3QPYIVG.js";
-import "../chunk-3YYRZDON.js";
+} from "../chunk-4R4GTZBZ.js";
 import {
   POLICY_EDIT_CANDIDATE_RECORD_SCHEMA,
   validatePolicyEditCandidateRecord
-} from "../chunk-5CVUPHJ4.js";
+} from "../chunk-EAWKAVID.js";
 import "../chunk-ARU2PZFM.js";
 import "../chunk-NJC7U437.js";
 import "../chunk-PJQFMIOX.js";
@@ -152,6 +153,7 @@ export {
   FsLabeledScenarioStore,
   LabeledScenarioStoreError,
   Lineage,
+  LineageStoreConflictError,
   POLICY_EDIT_CANDIDATE_RECORD_SCHEMA,
   ProfileMatrixError,
   SEARCH_LEDGER_SCHEMA,
@@ -173,6 +175,7 @@ export {
   buildLoopProvenanceRecord,
   callbackGovernor,
   campaignBreakdown,
+  campaignLineageStore,
   campaignMeanComposite,
   campaignMeasurementDigest,
   campaignScenarioIdentity,

package/dist/{chunk-N3QPYIVG.js → chunk-4R4GTZBZ.js}

@@ -1339,15 +1339,6 @@ export {
   inMemoryVerdictCache,
   fileVerdictCache,
   cachedJudge,
-  assertCampaignDesign,
-  campaignScenarioIdentity,
-  campaignSplitDigestFromIdentities,
-  campaignSplitDigest,
-  assertCampaignSplitIdentity,
-  campaignCoverage,
-  formatCoverageFailures,
-  tangleTracesRoot,
-  resolveRunDir,
   probeAtomicFileLock,
   tryAcquireAtomicFileLock,
   SearchLedgerError,
@@ -1358,7 +1349,16 @@ export {
   fsCampaignStorage,
   inMemoryCampaignStorage,
   createRunCostLedger,
+  assertCampaignDesign,
+  campaignScenarioIdentity,
+  campaignSplitDigestFromIdentities,
+  campaignSplitDigest,
+  assertCampaignSplitIdentity,
+  campaignCoverage,
+  formatCoverageFailures,
+  tangleTracesRoot,
+  resolveRunDir,
   runCampaign,
   planCampaignRun
 };
-//# sourceMappingURL=chunk-N3QPYIVG.js.map
+//# sourceMappingURL=chunk-4R4GTZBZ.js.map

package/dist/{chunk-EXMKNOP5.js → chunk-75OCWDXJ.js}

@@ -15,13 +15,14 @@ import {
   runImprovementLoop,
   surfaceContentHash,
   surfaceHash
-} from "./chunk-U4R2AGY5.js";
+} from "./chunk-MWN2X7C5.js";
 import {
   SearchLedgerConflictError,
   SearchLedgerError,
   SearchLedgerIntegrityError,
   appendSearchLedgerLine,
   assertRealBackend,
+  canonicalJson,
   contentHash,
   createRunCostLedger,
   fsCampaignStorage,
@@ -32,13 +33,11 @@ import {
   summarizeBackendIntegrity,
   tryAcquireAtomicFileLock,
   withSearchLedgerFileLock
-} from "./chunk-N3QPYIVG.js";
-import {
-  Mutex
-} from "./chunk-3YYRZDON.js";
+} from "./chunk-4R4GTZBZ.js";
 import {
   AnalystRegistry,
   DEFAULT_TRACE_ANALYST_KINDS,
+  Mutex,
   POLICY_EDIT_AXES,
   POLICY_EDIT_TARGET_SURFACES,
   admitPolicyEdit,
@@ -49,9 +48,10 @@ import {
   isPolicyEdit,
   makePolicyEdit,
   makePolicyEditCandidateRecord,
+  mapConcurrent,
   policyEditsFromFindings,
   validatePolicyEditCandidateRecord
-} from "./chunk-5CVUPHJ4.js";
+} from "./chunk-EAWKAVID.js";
 import {
   callLlm,
   callLlmJson,
@@ -94,7 +94,6 @@ import {
 
 // src/campaign/lineage.ts
 import { createHash } from "crypto";
-import { appendFile, mkdir, readFile, writeFile } from "fs/promises";
 import { dirname } from "path";
 function lineageNodeId(input) {
   const parents = [...input.parentIds].sort().join(",");
@@ -296,30 +295,71 @@ function dominates(a, b) {
   }
   return strictlyBetter;
 }
-function fsLineageStore(path) {
-  const ensureDir = () => mkdir(dirname(path), { recursive: true });
+var LineageStoreConflictError = class extends Error {
+  name = "LineageStoreConflictError";
+};
+function campaignLineageStore(storage, path, options = {}) {
+  const maxAppendAttempts = options.maxAppendAttempts ?? 100;
+  if (!Number.isInteger(maxAppendAttempts) || maxAppendAttempts < 1) {
+    throw new Error("campaignLineageStore: maxAppendAttempts must be a positive integer");
+  }
+  storage.ensureDir(dirname(path));
+  const read = () => {
+    const stored = storage.read(path);
+    if (stored === void 0 && storage.exists(path)) {
+      throw new Error(`campaignLineageStore: cannot read existing lineage '${path}'`);
+    }
+    const text = stored ?? "";
+    return { text, lineage: Lineage.fromJSONL(text) };
+  };
   return {
     async load() {
-      try {
-        return Lineage.fromJSONL(await readFile(path, "utf8"));
-      } catch (err) {
-        if (err.code === "ENOENT") return new Lineage();
-        throw err;
-      }
+      return read().lineage;
     },
     async append(node) {
-      await ensureDir();
-      await appendFile(path, `${JSON.stringify(node)}
-`, "utf8");
+      if (!storage.append) {
+        throw new Error("campaignLineageStore: CampaignStorage.append is required");
+      }
+      for (let attempt = 0; attempt < maxAppendAttempts; attempt += 1) {
+        const { text, lineage } = read();
+        const existing = lineage.get(node.id);
+        if (existing) {
+          assertSamePersistedNode(existing, node, "campaignLineageStore");
+          return;
+        }
+        for (const parentId of node.parentIds) {
+          if (!lineage.has(parentId)) {
+            throw new LineageStoreConflictError(
+              `campaignLineageStore: node '${node.id}' has unknown persisted parent '${parentId}'`
+            );
+          }
+        }
+        const persisted = lineage.all();
+        const expectedSeq = persisted.length === 0 ? 0 : Math.max(...persisted.map((entry) => entry.seq)) + 1;
+        if (node.seq !== expectedSeq) {
+          throw new LineageStoreConflictError(
+            `campaignLineageStore: stale controller tried sequence ${node.seq}; expected ${expectedSeq}`
+          );
+        }
+        const line = `${JSON.stringify(node)}
+`;
+        const expectedBytes = new TextEncoder().encode(text).byteLength;
+        if (storage.append(path, line, expectedBytes) !== void 0) return;
+      }
+      throw new LineageStoreConflictError(
+        `campaignLineageStore: could not append after ${maxAppendAttempts} attempts`
+      );
     },
     async save(lineage) {
-      await ensureDir();
       const jsonl = lineage.toJSONL();
-      await writeFile(path, jsonl.length > 0 ? `${jsonl}
-` : "", "utf8");
+      storage.write(path, jsonl.length > 0 ? `${jsonl}
+` : "");
     }
   };
 }
+function fsLineageStore(path) {
+  return campaignLineageStore(fsCampaignStorage(), path);
+}
 function memLineageStore() {
   const nodes = [];
   return {
@@ -327,6 +367,11 @@ function memLineageStore() {
       return new Lineage(nodes);
     },
     async append(node) {
+      const existing = nodes.find((entry) => entry.id === node.id);
+      if (existing) {
+        assertSamePersistedNode(existing, node, "memLineageStore");
+        return;
+      }
       nodes.push(node);
     },
     async save(lineage) {
@@ -335,6 +380,13 @@ function memLineageStore() {
     }
   };
 }
+function assertSamePersistedNode(existing, candidate, store) {
+  if (canonicalJson(existing) !== canonicalJson(candidate)) {
+    throw new LineageStoreConflictError(
+      `${store}: node '${candidate.id}' already exists with different content`
+    );
+  }
+}
 function heuristicGovernor(opts = {}) {
   const maxTracks = opts.maxTracks ?? 3;
   const plateauSteps = opts.plateauSteps ?? 2;
@@ -390,11 +442,35 @@ function isPlateaued(trackNodes, window) {
   return bestRecent <= bestBefore;
 }
 async function runLineage(opts) {
+  if (!Number.isInteger(opts.budget.maxSteps) || opts.budget.maxSteps < 0) {
+    throw new Error("runLineage: budget.maxSteps must be a non-negative integer");
+  }
+  if (opts.budget.maxNodes !== void 0 && (!Number.isInteger(opts.budget.maxNodes) || opts.budget.maxNodes < 0)) {
+    throw new Error("runLineage: budget.maxNodes must be a non-negative integer");
+  }
   const store = opts.store ?? memLineageStore();
   const lineage = await store.load();
   const log = opts.log ?? (() => {
   });
   const pruned = /* @__PURE__ */ new Set();
+  if (opts.budget.maxNodes !== void 0) {
+    const missingSeedIds = new Set(
+      opts.seeds.map(
+        (seed) => lineageNodeId({
+          parentIds: [],
+          track: seed.track,
+          surface: seed.surface,
+          proposer: seed.proposer
+        })
+      ).filter((id) => !lineage.has(id))
+    );
+    const available = Math.max(0, opts.budget.maxNodes - lineage.all().length);
+    if (missingSeedIds.size > available) {
+      throw new Error(
+        `runLineage: seed set requires ${missingSeedIds.size} new nodes but budget.maxNodes has ${available} slots remaining`
+      );
+    }
+  }
   const trackProposer = /* @__PURE__ */ new Map();
   const persist = async (node) => {
     await store.append(node);
@@ -414,10 +490,18 @@ async function runLineage(opts) {
   }
   let steps = 0;
   while (steps < opts.budget.maxSteps) {
+    if (opts.budget.maxNodes !== void 0 && lineage.all().length >= opts.budget.maxNodes) {
+      log("lineage: persisted node limit reached", {
+        maxNodes: opts.budget.maxNodes,
+        nodes: lineage.all().length
+      });
+      break;
+    }
+    const nodeBudgetRemaining = opts.budget.maxNodes === void 0 ? Number.POSITIVE_INFINITY : opts.budget.maxNodes - lineage.all().length;
     const op = await opts.governor.decide({
       lineage,
       step: steps,
-      budgetRemaining: opts.budget.maxSteps - steps,
+      budgetRemaining: Math.min(opts.budget.maxSteps - steps, nodeBudgetRemaining),
       prunedTracks: [...pruned]
     });
     if (op.op === "stop") {
@@ -2940,14 +3024,14 @@ function parameterSweepProposer(opts) {
       const parse = opts.parse ?? parseJsonObject;
       const stringify = opts.stringify ?? ((config) => JSON.stringify(config, null, 2));
       const current = parse(ctx.currentSurface);
-      const currentCanonical = canonicalJson(current);
+      const currentCanonical = canonicalJson2(current);
       const tried = triedLabels(ctx.history);
       const out = [];
       for (const candidate of opts.candidates) {
         if (tried.has(candidate.label)) continue;
         const next = applyParameterCandidate(current, candidate);
         const surface = stringify(next);
-        if (surface === ctx.currentSurface || canonicalJson(next) === currentCanonical) continue;
+        if (surface === ctx.currentSurface || canonicalJson2(next) === currentCanonical) continue;
         out.push({ surface, label: candidate.label, rationale: candidate.rationale });
         if (out.length >= ctx.populationSize) break;
       }
@@ -3024,10 +3108,10 @@ function assertSafeJsonKey(key) {
     throw new Error(`parameterSweepProposer: unsafe JSON key "${key}" is not allowed`);
   }
 }
-function canonicalJson(value) {
-  if (Array.isArray(value)) return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+function canonicalJson2(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => canonicalJson2(item)).join(",")}]`;
   if (isPlainObject(value)) {
-    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson2(value[key])}`).join(",")}}`;
   }
   return JSON.stringify(value);
 }
@@ -4214,9 +4298,13 @@ function toCandidate(p) {
 async function runLineageLoop(opts) {
   const governor = opts.governor ?? heuristicGovernor();
   const populationSize = opts.populationSize ?? 4;
+  const candidateConcurrency = opts.candidateConcurrency ?? 1;
   if (populationSize < 1) {
     throw new Error("runLineageLoop: populationSize must be >= 1");
   }
+  if (!Number.isInteger(candidateConcurrency) || candidateConcurrency < 1) {
+    throw new Error("runLineageLoop: candidateConcurrency must be a positive integer");
+  }
   let proposer = opts.proposer;
   if (!proposer) {
     if (!opts.llm || !opts.model) {
@@ -4282,18 +4370,17 @@ async function runLineageLoop(opts) {
     objectives.composite = node.score;
     return objectives;
   };
-  const scoredSeeds = [];
-  for (const seed of opts.seeds) {
+  const scoredSeeds = await mapConcurrent(opts.seeds, candidateConcurrency, async (seed) => {
     const measured = await scoreSurface(seed.surface);
-    scoredSeeds.push({
+    return {
       surface: seed.surface,
       track: seed.track,
       proposer: seed.proposer,
       score: measured.score,
       ...seed.vision !== void 0 ? { vision: seed.vision } : {},
       ...measured.scoreVector !== void 0 ? { scoreVector: measured.scoreVector } : {}
-    });
-  }
+    };
+  });
   const step = async (args) => {
     const proposed = await proposer.propose({
       currentSurface: args.tip.surface,
@@ -4312,16 +4399,21 @@ async function runLineageLoop(opts) {
         ...args.tip.rationale !== void 0 ? { rationale: args.tip.rationale } : {}
       }
     ];
-    for (const p of proposed) {
-      const { surface, rationale } = toCandidate(p);
-      const measured = await scoreSurface(surface);
-      pool.push({
-        surface,
-        score: measured.score,
-        ...measured.scoreVector !== void 0 ? { scoreVector: measured.scoreVector } : {},
-        ...rationale !== void 0 ? { rationale } : {}
-      });
-    }
+    const measuredCandidates = await mapConcurrent(
+      proposed,
+      candidateConcurrency,
+      async (p) => {
+        const { surface, rationale } = toCandidate(p);
+        const measured = await scoreSurface(surface);
+        return {
+          surface,
+          score: measured.score,
+          ...measured.scoreVector !== void 0 ? { scoreVector: measured.scoreVector } : {},
+          ...rationale !== void 0 ? { rationale } : {}
+        };
+      }
+    );
+    pool.push(...measuredCandidates);
     let best = pool[0];
     for (const entry of pool) {
       if (entry.score > best.score) best = entry;
@@ -8050,6 +8142,8 @@ export {
   agentProfileHash,
   lineageNodeId,
   Lineage,
+  LineageStoreConflictError,
+  campaignLineageStore,
   fsLineageStore,
   memLineageStore,
   heuristicGovernor,
@@ -8116,4 +8210,4 @@ export {
   verifyCodeSurface,
   resolveWorktreePath
 };
-//# sourceMappingURL=chunk-EXMKNOP5.js.map
+//# sourceMappingURL=chunk-75OCWDXJ.js.map