@tangle-network/agent-runtime 0.172.0 → 0.174.0

package/dist/{improvement-cycle-ipnDcl3P.js → improvement-cycle-BZH9dewp.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 { H as createExecutor, Xt as runSettledCommand } from "./supervisor-Dw-5mGKr.js";
-import { D as optimizerMethod, a as defaultStructuralRolloutPolicy } from "./structural-rollout-DjUoh2aA.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 { 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 } 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
 /**
 *
@@ -28,9 +95,12 @@ import { measuredComparisonFromAgentProfileImprovementExperiment, measuredCompar
 *
 * Every paid shot enters Runtime through `createExecutor` + `streamAgentTurn`.
 * The caller supplies the exact `AgentProfile` and a worktree-aware executor
-* placement; Runtime validates and records the profile that actually ran. A
-* cli-bridge placement sets `cwd` to the supplied worktree so Pi and other
-* supported harnesses edit the existing candidate directly.
+* placement; Runtime validates and records the profile that actually ran. Two
+* built-in placements edit the supplied worktree itself: `{ backend:'cli-in-place',
+* workspacePath: worktreePath }` runs a local coding CLI (claude-code / codex /
+* opencode / pi) in that directory, and `{ backend:'bridge', cwd: worktreePath }`
+* runs a cli-bridge session there. `cli-worktree` is NOT one of them — it cuts a
+* worktree of its own, so every shot would read as an empty tree.
 *
 * `maxShots` is the DEPTH dial — a multi-shot verify-in-session loop, NOT the
 * kernel `runAgentRounds`. Each shot runs one full harness session in the (persistent)
@@ -40,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";
@@ -68,13 +148,37 @@ function agenticGenerator(opts) {
 			const basePrompt = opts.buildPrompt({ findings });
 			if (typeof basePrompt !== "string" || basePrompt.trim().length === 0) throw new Error("agenticGenerator: buildPrompt must return a non-empty string");
 			const executorConfig = opts.executorForWorktree(worktreePath);
-			if (executorConfig.backend === "bridge" && executorConfig.cwd !== worktreePath) throw new Error("agenticGenerator: bridge executor cwd must equal the candidate worktree path");
+			if (executorConfig.backend === "bridge" && !samePath(executorConfig.cwd, worktreePath)) throw new Error("agenticGenerator: bridge executor cwd must equal the candidate worktree path");
+			if (executorConfig.backend === "cli-in-place" && !samePath(executorConfig.workspacePath, worktreePath)) throw new Error("agenticGenerator: cli-in-place executor workspacePath must equal the candidate worktree path");
 			const factory = createExecutor(executorConfig);
 			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;
@@ -140,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");
@@ -186,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);
@@ -201,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, {
@@ -220,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: ""
@@ -227,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);
@@ -369,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);
@@ -471,6 +622,24 @@ function truncate$1(s, n) {
 *  something is genuinely broken (git missing, corrupt index, killed mid-run).
 *  Folding that into `false` would silently discard a candidate and mask the
 *  real failure — forbidden by the no-silent-fallbacks doctrine. */
+/** Do two names address the same directory? An in-place placement is only in-place if it names the
+*  worktree the driver created, and a byte comparison answers that wrongly on a platform whose
+*  temporary directory is a symlink: macOS reports `/var/folders/...` where the resolved path is
+*  `/private/var/folders/...`, and both are the same directory. */
+function samePath(candidate, worktreePath) {
+	if (typeof candidate !== "string" || candidate.length === 0) return false;
+	if (candidate === worktreePath) return true;
+	return canonicalPath(candidate) === canonicalPath(worktreePath);
+}
+/** The resolved path, or the lexically absolute one when the name does not exist — a name that
+*  cannot be resolved is a mismatch the caller is told about, not an error to swallow. */
+function canonicalPath(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return resolve(path);
+	}
+}
 function worktreeDirty(worktreePath) {
 	return worktreeChangedPaths(worktreePath).length > 0;
 }
@@ -3058,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-ipnDcl3P.js.map
+//# sourceMappingURL=improvement-cycle-BZH9dewp.js.map