@tangle-network/agent-runtime 0.173.0 → 0.174.1

package/dist/{improvement-cycle-lP-F7B60.js → improvement-cycle-DKGDCukL.js}

@@ -3,8 +3,8 @@ import { n as streamAgentTurn, t as collectAgentTurn } from "./stream-agent-turn
 import { n as detachedSnapshot } from "./snapshot-CTAf4uuA.js";
 import { $ as parseAgentCandidateProfileActivation, J as assertCandidateProfileBinding, K as agentCandidateProfileAsAgentProfile, Q as omitUndefinedObjectFields, Y as createAgentCandidateProfileActivation, Z as materializeAgentCandidateProfilePlan, at as canonicalCandidateDocument, ct as immutableCandidateValue, d as verifiedResourceTextByDigest, dt as verifyCanonicalCandidateDocument, et as parseExactAgentProfile, f as verifyAgentCandidateBundle, it as canonicalCandidateDigest$1, lt as omitTopLevelDigest, n as executePreparedAgentCandidate, q as applyExactAgentProfileDiff, rt as canonicalCandidateBytes, t as prepareAgentCandidateExecution } from "./prepare-BAyaNoZu.js";
 import { a as concreteProfileModel, t as assertExecutableAgentProfile } from "./model-policy-Sw4ywhtL.js";
-import { Qt as runSettledCommand, U as createExecutor } from "./supervisor-cAFpYJWF.js";
-import { D as optimizerMethod, a as defaultStructuralRolloutPolicy } from "./structural-rollout-CIK7nvSH.js";
+import { Qt as runSettledCommand, U as createExecutor } from "./supervisor-Bt1XLCVq.js";
+import { D as optimizerMethod, a as defaultStructuralRolloutPolicy } from "./structural-rollout-BUYA61iV.js";
 import { t as runAnalystLoop } from "./analyst-loop-Bouu53-l.js";
 import { AGENT_IMPROVEMENT_SOURCE_METADATA_KEY, agentCandidateMaterializationReceiptSchema, agentCandidateRunReceiptSchema, agentImprovementActivationSchema, agentImprovementProposalSchema, agentImprovementReviewSchema, agentImprovementSourceMetadata, agentImprovementSourceSchema, agentProfileDiffSchema, agentProfileImprovementArmSchema, agentProfileImprovementExecutionRefSchema, agentProfileModelHintsSchema, agentProfileSchema, applyAgentProfileDiff, candidateExecutionEvidenceSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, changedProfileImprovementSurfaces, defineAgentProfileDiff, diffAgentProfiles, numbersApproximatelyEqual, sha256DigestSchema } from "@tangle-network/agent-interface";
 import { CostLedger, canonicalJson, makeProposalFinding } from "@tangle-network/agent-eval";
@@ -12,11 +12,78 @@ import { campaignScenarioIdentity, campaignSplitDigestFromIdentities, compareOpt
 import { createHash, randomUUID } from "node:crypto";
 import { basename, join, resolve } from "node:path";
 import { realpath } from "node:fs/promises";
-import { existsSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync } from "node:fs";
 import { spawnSync } from "node:child_process";
+import { tmpdir } from "node:os";
 import { isDeepStrictEqual } from "node:util";
 import { assertProposalFindings } from "@tangle-network/agent-eval/analyst";
 import { measuredComparisonFromAgentProfileImprovementExperiment, measuredComparisonFromCandidateExperiment, runAgentProfileImprovementExperiment, runCandidateExperiment, sealAgentProfileImprovementExperiment, sealAgentProfileImprovementSuite, sealAgentProfileImprovementTask, sealCandidateExperiment, selfImprove, verifyAgentProfileImprovementExperimentComparison, verifyCandidateExperiment, verifyCandidateExperimentComparison } from "@tangle-network/agent-eval/contract";
+//#region src/improvement/worktree-tree.ts
+/**
+* The exact content of a candidate worktree, as a Git tree object.
+*
+* A multi-shot candidate edits ONE directory in place, so the tree a shot
+* produced is gone as soon as the next shot writes over it. Writing that
+* content into the object store is what makes an earlier tree recoverable:
+* `agenticGenerator` snapshots a tree that verified, and puts it back when a
+* later shot ends the budget on a worse one.
+*
+* The snapshot stages into a PRIVATE index file, so the index the driver later
+* commits from is untouched.
+*/
+/** Write the worktree's current content into the object store and return its tree id. */
+function snapshotWorktreeTree(worktreePath) {
+	const scratch = mkdtempSync(join(tmpdir(), "agentic-generator-tree-"));
+	const indexFile = join(scratch, "index");
+	try {
+		git(worktreePath, ["read-tree", "HEAD"], indexFile);
+		git(worktreePath, ["add", "--all"], indexFile);
+		return git(worktreePath, ["write-tree"], indexFile);
+	} finally {
+		rmSync(scratch, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/**
+* Put a snapshotted tree back into the worktree, then prove the directory
+* holds exactly that tree.
+*
+* The proof is not ceremony: a restore that lands the wrong bytes ships the
+* wrong candidate, and every artifact downstream still reads as though the
+* best tree shipped.
+*/
+function restoreWorktreeTree(worktreePath, tree) {
+	git(worktreePath, [
+		"read-tree",
+		"-u",
+		"--reset",
+		tree
+	]);
+	git(worktreePath, [
+		"clean",
+		"--force",
+		"-d",
+		"--quiet"
+	]);
+	const restored = snapshotWorktreeTree(worktreePath);
+	if (restored !== tree) throw new Error(`agenticGenerator: restoring tree ${tree} into ${worktreePath} produced ${restored}`);
+}
+function git(cwd, args, indexFile) {
+	const env = { ...process.env };
+	if (indexFile) env.GIT_INDEX_FILE = indexFile;
+	else delete env.GIT_INDEX_FILE;
+	const result = spawnSync("git", args, {
+		cwd,
+		encoding: "utf-8",
+		env
+	});
+	if (result.error) throw new Error(`agenticGenerator: git ${args[0]} failed to spawn in ${cwd}: ${result.error.message}`);
+	if (result.status !== 0) throw new Error(`agenticGenerator: git ${args[0]} exited ${result.status} in ${cwd}: ${result.stderr.trim()}`);
+	return result.stdout.trim();
+}
+//#endregion
 //#region src/improvement/agentic-generator.ts
 /**
 *
@@ -43,10 +110,20 @@ import { measuredComparisonFromAgentProfileImprovementExperiment, measuredCompar
 *       (the worktree persists, so the harness RESUMES atop its own failing
 *       edits with the error in hand — no session-specific retry path needed)
 *   - dirty + `verify` ok (or no verifier configured) → return the candidate
+*   - dirty + `verify` ok + `keepGoing` → bank the tree and spend the next shot
 * A candidate that never verifies within `maxShots` is discarded (`applied:
 * false`), never shipped — if you configured a verifier, a non-passing tree is
 * not a candidate. With no verifier, the first dirty shot is the candidate.
 *
+* BEST-OF-N is the `keepGoing` path, and the loop owns it end to end. A
+* verifier that passes a tree and asks for another shot has its tree
+* snapshotted as a Git tree object; when the budget ends, the highest-`score`
+* tree is RESTORED into the worktree and returned as the candidate. So the
+* caller ranks and the loop moves the bytes — a caller never has to write a
+* passing tree back itself. The budget ends on the last shot, or earlier on a
+* `keepGoing`-less pass, and a last shot that broke or reverted the change does
+* not cost the candidate the verified tree an earlier shot produced.
+*
 * @stable
 */
 const RAW_TRACE_ANALYST_ID = "raw-trace-distiller";
@@ -77,8 +154,31 @@ function agenticGenerator(opts) {
 			const needsRawTraceEvidence = requiresRawTraceEvidence(findings);
 			const shots = Math.max(1, maxShots);
 			let attemptNote = "";
+			let best = null;
+			let scored = null;
+			let lastReceipt = null;
+			/** Ship the best tree this candidate produced, restoring it when a later
+			*  shot wrote over it. */
+			const shipBankedTree = async (receipt, banked) => {
+				const restoredFromShot = banked.onDisk ? null : banked.shot;
+				if (!banked.onDisk) {
+					if (banked.tree === null) throw new Error(`agenticGenerator: shot ${banked.shot} produced the best tree but it was never snapshotted`);
+					restoreWorktreeTree(worktreePath, banked.tree);
+					banked.onDisk = true;
+				}
+				signal.throwIfAborted();
+				await emitShotDisposition(opts.onShotDisposition, receipt, {
+					kind: "accepted",
+					worktreePath,
+					verified: true,
+					restoredFromShot
+				});
+				signal.throwIfAborted();
+				return acceptedCandidate(findings);
+			};
 			for (let shot = 0; shot < shots; shot++) {
 				signal.throwIfAborted();
+				if (best) best.onDisk = false;
 				const taskPrompt = attemptNote ? `${basePrompt}\n\n${attemptNote}` : basePrompt;
 				const startedAt = /* @__PURE__ */ new Date();
 				let turn = null;
@@ -144,6 +244,7 @@ function agenticGenerator(opts) {
 					costReceipt,
 					error: shotError
 				});
+				lastReceipt = receipt;
 				await emitShotReceipt(opts.onShotCompleted, receipt, execution, shotError);
 				signal.throwIfAborted();
 				if (!execution) throw new Error("agenticGenerator: author shot completed without a Runtime turn");
@@ -190,7 +291,8 @@ function agenticGenerator(opts) {
 					await emitShotDisposition(opts.onShotDisposition, receipt, {
 						kind: "accepted",
 						worktreePath,
-						verified: false
+						verified: false,
+						restoredFromShot: null
 					});
 					signal.throwIfAborted();
 					return acceptedCandidate(findings);
@@ -205,14 +307,35 @@ function agenticGenerator(opts) {
 					return rethrowShotSetupError(opts.onShotDisposition, receipt, worktreePath, "verification", cause);
 				}
 				if (result.ok) {
+					const score = admittedScore(result, scored, shot);
+					scored = score !== null;
+					const previousBest = best;
+					let banked;
+					if (previousBest === null || (score ?? 0) >= (previousBest.score ?? 0)) banked = {
+						shot: shot + 1,
+						score,
+						tree: null,
+						onDisk: true
+					};
+					else banked = previousBest;
+					const becomesBest = banked !== previousBest;
+					best = banked;
+					if (result.keepGoing !== true) {
+						signal.throwIfAborted();
+						return await shipBankedTree(receipt, banked);
+					}
+					if (becomesBest && shot < shots - 1) banked.tree = snapshotWorktreeTree(worktreePath);
 					signal.throwIfAborted();
 					await emitShotDisposition(opts.onShotDisposition, receipt, {
-						kind: "accepted",
+						kind: "kept",
 						worktreePath,
-						verified: true
+						score,
+						best: becomesBest,
+						feedback: result.feedback ?? null
 					});
 					signal.throwIfAborted();
-					return acceptedCandidate(findings);
+					attemptNote = keptNote(result.feedback);
+					continue;
 				}
 				signal.throwIfAborted();
 				await emitShotDisposition(opts.onShotDisposition, receipt, {
@@ -224,6 +347,10 @@ function agenticGenerator(opts) {
 				signal.throwIfAborted();
 				attemptNote = failureNote(result.feedback);
 			}
+			if (best !== null) {
+				if (!lastReceipt) throw new Error("agenticGenerator: a tree was banked without a shot receipt");
+				return await shipBankedTree(lastReceipt, best);
+			}
 			return {
 				applied: false,
 				summary: ""
@@ -231,6 +358,14 @@ function agenticGenerator(opts) {
 		}
 	};
 }
+/** The rank a passing tree carries, refusing a set of trees that cannot be ordered. */
+function admittedScore(result, scored, shot) {
+	const has = result.score !== void 0;
+	if (scored !== null && has !== scored) throw new Error(`agenticGenerator: verify ${has ? "scored" : "did not score"} the tree from shot ${shot + 1} and ${scored ? "scored" : "did not score"} an earlier passing tree; a scored tree cannot be ranked against an unscored one`);
+	if (!has) return null;
+	if (typeof result.score !== "number" || !Number.isFinite(result.score)) throw new Error(`agenticGenerator: verify returned a non-finite score (${String(result.score)}) for shot ${shot + 1}`);
+	return result.score;
+}
 async function emitShotReceipt(callback, receipt, execution, primaryError) {
 	try {
 		await callback?.(receipt, execution);
@@ -373,6 +508,18 @@ function failureNote(feedback) {
 		detail ? `Verifier output:\n${truncate$1(detail, 4e3)}` : "No verifier detail was captured."
 	].join("\n");
 }
+/** Next-shot feedback when the worktree PASSED and the verifier asked for
+*  another shot. The passing tree is banked, so the author is told to improve
+*  it rather than protect it — a worse tree cannot cost it the candidate. */
+function keptNote(feedback) {
+	const detail = feedback?.trim();
+	return [
+		"NOTE: your edits are in the working tree and verification PASSED.",
+		"Shots remain in this budget — keep improving the change in place, do not revert it.",
+		"The best version you produce is the one that ships.",
+		detail ? `Verifier output:\n${truncate$1(detail, 4e3)}` : "No verifier detail was captured."
+	].join("\n");
+}
 function rawTraceEvidenceProblem(worktreePath, findings) {
 	if (worktreeChangedPaths(worktreePath).filter((path) => path !== RAW_TRACE_DIAGNOSIS_PATH).length === 0) return [`NOTE: raw-trace mode requires a real code/config edit in addition to ${RAW_TRACE_DIAGNOSIS_PATH}.`, "Your previous attempt only changed the diagnosis artifact. Inspect the cited traces and make the causal code change."].join("\n");
 	const diagnosisPath = join(worktreePath, RAW_TRACE_DIAGNOSIS_PATH);
@@ -3080,4 +3227,4 @@ function sameOrderedValues(left, right) {
 //#endregion
 export { agentImprovementTargetInput as A, ROLLOUT_POLICY_EXTENSION as B, optimizationActivationReceiptFromMetadata as C, agentImprovementProfileSurfaceDigest as D, agentImprovementProfileDiffs as E, isAgentImprovementProfileSurface as F, structuralRolloutPolicyFromProfile as G, normalizeRolloutPolicy as H, isAgentProfileMeasuredSurface as I, defaultBuildPrompt as J, agenticGenerator as K, improve as L, agentProfileImprovementStateDigest as M, assertProfileImprovementTargetsShareIdentity as N, agentImprovementProfileSurfaceInput as O, buildAgentImprovementActivationTargets as P, withMethodRuntimeControls as R, createOptimizationActivationReceipt as S, AGENT_PROFILE_MEASURED_SURFACES as T, parseRolloutPolicy as U, applyRolloutPolicyToProfile as V, serializeRolloutPolicy as W, profilePolicyWithBudget as _, executeAgentCandidateExperimentCell as a, profileTaskScenarioIdentity as b, requireSealedCandidateExperiment as c, verifyAgentImprovementActivation as d, verifyAgentImprovementProposal as f, profileImprovementMetadata as g, createProfileImprovementCostLedger as h, createAgentImprovementProposal as i, agentImprovementTargetProfileDiffs as j, agentImprovementTargetDigest as k, reviewAgentImprovementProposal as l, verifyCandidateExecutionEvidence as m, createAgentImprovementActivation as n, proposeAgentImprovement as o, verifyAgentImprovementReview as p, commandVerifier as q, createAgentImprovementMeasuredComparison as r, proposeAgentProfileImprovement as s, AgentCandidateExperimentCellExecutionError as t, runAgentCandidateExperiment as u, profilePreparationAccounting as v, AGENT_IMPROVEMENT_PROFILE_SURFACES as w, sealProfileImprovementBenchmark as x, profileStateDigest as y, rawTraceDistiller as z };
 
-//# sourceMappingURL=improvement-cycle-lP-F7B60.js.map
+//# sourceMappingURL=improvement-cycle-DKGDCukL.js.map