@tangle-network/agent-runtime 0.296.0 → 0.297.2

package/dist/agent.d.ts

@@ -1,6 +1,6 @@
 import { Ma as OutputAdapter, Pa as SandboxClient, la as AgentRunSpec, po as RuntimeStreamEvent } from "./types-CwGpKzG1.js";
 import { a as createSurfaceImprovementProposer, c as SurfaceValidationIssue, d as validateSurfaces, i as SurfaceImprovementEdit, l as renderSurfaceIssues, n as DraftPatchInput, o as AgentSurfaces, r as DraftPatchOutput, s as ResolvedSurface, t as CreateSurfaceImprovementProposerOptions, u as resolveSubjectPath } from "./improvement-adapter-D5gwwoXQ.js";
-import { $h as ValidateProfileMaterializationOptions, Gh as AGENT_PROFILE_MATERIALIZATION_AXES, Jh as CanonicalAgentProfileMaterializationAxis, Kh as AgentProfileMaterializationAxis, Qh as ProfileMaterializationIssue, Xh as KnownAgentProfileMaterializationAxis, Yh as DefineProfileMaterializationContractOptions, Zh as ProfileMaterializationContract, ag as promptControlProfileMaterialization, cg as promptResourceProfileMaterialization, dg as validateProfileMaterialization, eg as assertProfileMaterialization, fg as worktreeCliProfileMaterialization, ig as profileMaterializationAxes, lg as renderProfileMaterializationIssues, ng as defineProfileMaterializationContract, og as promptModelProfileMaterialization, qh as AssertProfileMaterializationOptions, rg as fullProfileMaterialization, sg as promptOnlyProfileMaterialization, tg as controlProfileMaterialization, ug as sandboxActProfileMaterialization } from "./index-3GzNNtI9.js";
+import { $h as ProfileMaterializationIssue, Jh as AssertProfileMaterializationOptions, Kh as AGENT_PROFILE_MATERIALIZATION_AXES, Qh as ProfileMaterializationContract, Xh as DefineProfileMaterializationContractOptions, Yh as CanonicalAgentProfileMaterializationAxis, Zh as KnownAgentProfileMaterializationAxis, ag as profileMaterializationAxes, cg as promptOnlyProfileMaterialization, dg as sandboxActProfileMaterialization, eg as ValidateProfileMaterializationOptions, fg as validateProfileMaterialization, ig as fullProfileMaterialization, lg as promptResourceProfileMaterialization, ng as controlProfileMaterialization, og as promptControlProfileMaterialization, pg as worktreeCliProfileMaterialization, qh as AgentProfileMaterializationAxis, rg as defineProfileMaterializationContract, sg as promptModelProfileMaterialization, tg as assertProfileMaterialization, ug as renderProfileMaterializationIssues } from "./index-CrLf_h23.js";
 import { AgentProfile, AgentProfileFileMount, AgentProfileMcpServer } from "@tangle-network/agent-interface";
 import { TraceAnalystDefinition } from "@tangle-network/agent-eval";
 import { SandboxEvent } from "@tangle-network/sandbox";

package/dist/agent.js

@@ -1,5 +1,5 @@
 import { Ci as renderProfileMaterializationIssues, Di as validateProfileMaterialization, Oi as worktreeCliProfileMaterialization, Si as promptResourceProfileMaterialization, Ti as sandboxActProfileMaterialization, _i as fullProfileMaterialization, bi as promptModelProfileMaterialization, gi as defineProfileMaterializationContract, hi as controlProfileMaterialization, la as mapSandboxEvent, mi as assertProfileMaterialization, pi as AGENT_PROFILE_MATERIALIZATION_AXES, pn as createSandboxForSpec, vi as profileMaterializationAxes, xi as promptOnlyProfileMaterialization, yi as promptControlProfileMaterialization } from "./supervisor-Rov7xW0j.js";
-import "./runtime-DicgLBWl.js";
+import "./runtime-C-jN8ONc.js";
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";

package/dist/{coordination-driver-BTwCdKrl.js → coordination-driver-C3ox4-8J.js}

@@ -1,7 +1,7 @@
 import { $i as detachedFrozen, $n as parseWorkerToolTraceArtifact, Aa as addResourceSpend, Ai as prepareJsonlAppend, Bn as InMemoryResultBlobStore, Da as unmeteredSpend, E as failedItems, It as createRouterTranscript, Lr as resolveRedactor, M as withDriverExecutor, Ma as withBudgetResources, Mi as writeAllBytes, Qt as createPeerMailbox, Rn as FileResultBlobStore, Tn as runBrainLoop, Vi as providerAttemptEvidence, Vn as InMemorySpawnJournal, _ as CheckUnavailableError, c as runTree, er as workerTraceAnalysisStore, ft as resolveSpawnResourcePaths, ga as chargedTokens, i as bestDelivered, ir as assertValidBudget, ji as readCommittedJsonLines, jt as createExecutorRegistry, nn as isLiveNodeStatus, o as pickBestDelivered, ot as scopeRetainedOwnerResourceReader, qt as createInbox, rn as isTerminalNodeStatus, s as runFinalizer, ur as errMessage, x as checkVerdictOf, xa as promptCacheTokenClasses, z as meterRuntimeOwnedProviderAttempt, zn as FileSpawnJournal } from "./supervisor-Rov7xW0j.js";
 import { f as RuntimeRunStateError, m as ValidationError } from "./errors-DodWX-cb.js";
 import { A as writeWorkerCancellation, M as writeWorkerSteerAcknowledgement, b as workerCancellationsDir, c as readWorkerCancelRequests, d as readWorkerSteerRequests, k as writeRunCancellation, l as readWorkerCancellation, o as readRunCancelRequest, r as claimWorkerSteerDelivery, s as readRunCancellation, u as readWorkerSteerAcknowledgement } from "./run-layout-DSCWdbX2.js";
-import { agentProfileSchema, canonicalCandidateDigest } from "@tangle-network/agent-interface";
+import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest } from "@tangle-network/agent-interface";
 import { argHash, errorStreakDetector, observeAll, repeatedActionDetector } from "@tangle-network/agent-eval";
 import { randomUUID } from "node:crypto";
 import { mkdirSync, readFileSync, watch } from "node:fs";
@@ -558,6 +558,7 @@ const journalEventKinds = [
 	"mail",
 	"escalation",
 	"analyst-defined",
+	"analyst-assignment",
 	"acknowledgement"
 ];
 /** The reserved coordination verb names — the complete set `createCoordinationTools` can emit
@@ -919,8 +920,56 @@ function createCoordinationToolsForManager(opts, lifetime) {
 			reason: settled.reason
 		});
 	};
+	const analystAssignments = /* @__PURE__ */ new Map();
+	for (const record of opts.priorJournal ?? []) {
+		if (record.event.type !== "analyst-assignment") continue;
+		const assignment = record.event.assignment;
+		const prior = analystAssignments.get(assignment.assignmentId);
+		if (prior && canonicalCandidateDigest(prior) !== canonicalCandidateDigest(assignment)) throw new Error(`coordination: conflicting analyst assignment '${assignment.assignmentId}'`);
+		analystAssignments.set(assignment.assignmentId, detachedFrozen(assignment));
+	}
+	const analystRuns = /* @__PURE__ */ new Map();
+	const flushedAnalystRuns = /* @__PURE__ */ new Set();
+	let analystRunOrdinal = 0;
+	for (const assignment of analystAssignments.values()) {
+		const ordinal = Number(/:o(\d+)$/.exec(assignment.assignmentId)?.[1]);
+		if (!Number.isSafeInteger(ordinal) || ordinal < 0 || ordinal === Number.MAX_SAFE_INTEGER) throw new Error(`coordination: invalid analyst assignment '${assignment.assignmentId}'`);
+		analystRunOrdinal = Math.max(analystRunOrdinal, ordinal + 1);
+	}
+	for (const node of [...opts.scope.resume?.view.nodes ?? [], ...opts.scope.view.nodes]) {
+		if (node.parent !== opts.scope.view.root || !node.assignmentId?.startsWith("analyst:")) continue;
+		const assignment = analystAssignments.get(node.assignmentId);
+		if (!assignment) throw new Error(`coordination: analyst assignment '${node.assignmentId}' has no durable source record; refusing to treat its review as a worker result`);
+		if (node.identity && (node.identity.profileDigest !== assignment.profileDigest || node.identity.taskDigest !== assignment.taskDigest)) throw new Error(`coordination: analyst assignment '${node.assignmentId}' conflicts with its journaled execution identity`);
+		analystRuns.set(node.id, {
+			route: {
+				kind: assignment.kind,
+				...assignment.to === void 0 ? {} : { to: assignment.to }
+			},
+			sourceWorker: assignment.sourceWorker,
+			assignmentId: assignment.assignmentId
+		});
+	}
+	const analystRunFinding = (run, settled) => detachedFrozen({
+		type: "finding",
+		finding: canonicalFindingEvent({
+			fromWorker: run.sourceWorker,
+			analyst: run.route.kind,
+			analystWorkerId: settled.handle.id,
+			assignmentId: run.assignmentId,
+			findings: settled.kind === "done" ? settled.out : { analystRunFailed: settled.reason }
+		})
+	});
 	const resumedWorkers = [];
+	const resumedFindings = [];
 	for (const s of opts.scope.resume?.settled ?? []) {
+		const analyst = analystRuns.get(s.handle.id);
+		if (analyst) {
+			resumedFindings.push(analystRunFinding(analyst, s));
+			analystRuns.delete(s.handle.id);
+			flushedAnalystRuns.add(s.handle.id);
+			continue;
+		}
 		const worker = projectSettled(s, true);
 		resumedWorkers.push(worker);
 		ledger.push(worker);
@@ -930,10 +979,10 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		const cb = opts.onEvent;
 		bus.subscribe((rec) => cb(rec.event, rec));
 	}
-	const resumeEvents = opts.replaySettlements ? resumedWorkers.map((worker) => detachedFrozen({
+	const resumeEvents = opts.replaySettlements ? [...resumedWorkers.map((worker) => detachedFrozen({
 		type: "settled",
 		worker
-	})) : [];
+	})), ...resumedFindings] : [];
 	let resumeEventIndex = 0;
 	let readyInFlight;
 	const ready = () => {
@@ -968,7 +1017,6 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		checkReads.push(entry);
 		return entry;
 	};
-	const flushedAnalystRuns = /* @__PURE__ */ new Set();
 	const eventWorker = (event) => event.type === "settled" ? event.worker.id : event.type === "finding" ? event.finding.fromWorker : event.type === "question" ? event.question.from : void 0;
 	const acknowledge = async (targets, by) => {
 		const fresh = targets.filter((delivery) => !delivery.acknowledged);
@@ -1036,18 +1084,6 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		unwatchWorker(w.id);
 	};
 	let pendingSettlement;
-	const analystRuns = /* @__PURE__ */ new Map();
-	let analystRunOrdinal = 0;
-	/** The `finding` event an analyst-agent settlement becomes: its settle OUTPUT is the findings
-	*  (a failed run publishes the failure as findings — degraded beats vanished). */
-	const analystRunFinding = (run, settled) => detachedFrozen({
-		type: "finding",
-		finding: canonicalFindingEvent({
-			fromWorker: run.sourceWorker,
-			analyst: run.route.kind,
-			findings: settled.kind === "done" ? settled.out : { analystRunFailed: settled.reason }
-		})
-	});
 	/**
 	* Spawn one analyst-AGENT run over a settled worker's evidence, through the SAME spawn
 	* machinery a driver spawn uses (`scope.spawn` + `makeWorkerAgent`): the analyst's spend
@@ -1073,6 +1109,22 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		].join("\n\n");
 		const assignmentId = `analyst:${route.kind}:o${analystRunOrdinal++}`;
 		const label = `analyst:${route.kind}`;
+		const assignment = detachedFrozen({
+			assignmentId,
+			kind: route.kind,
+			sourceWorker: worker.id,
+			sourceTrace: worker.trace,
+			...worker.outRef === void 0 ? {} : { sourceOutRef: worker.outRef },
+			profileDigest: canonicalAgentProfileDigest(route.agent),
+			taskDigest: canonicalCandidateDigest(task),
+			...route.directive === void 0 ? {} : { directive: route.directive },
+			...route.to === void 0 ? {} : { to: route.to }
+		});
+		await bus.publish({
+			type: "analyst-assignment",
+			assignment
+		}, { queue: false });
+		analystAssignments.set(assignmentId, assignment);
 		const context = Object.freeze({
 			assignmentId,
 			parentNodeId: opts.scope.view.root,
@@ -1108,8 +1160,10 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		}
 		analystRuns.set(spawnedId, {
 			route,
-			sourceWorker: worker.id
+			sourceWorker: worker.id,
+			assignmentId
 		});
+		if (route.agent?.name) profileNameByWorker.set(spawnedId, route.agent.name);
 		watchWorker(spawnedId);
 	};
 	const workerRouteNames = (workerId) => {
@@ -1498,6 +1552,10 @@ function createCoordinationToolsForManager(opts, lifetime) {
 			type: "analyst-defined",
 			...ev.analyst
 		};
+		if (ev.type === "analyst-assignment") return {
+			type: "analyst-assignment",
+			...ev.assignment
+		};
 		if (ev.type === "acknowledgement") return {
 			type: "acknowledgement",
 			...ev.acknowledgement
@@ -4557,7 +4615,7 @@ function resumeBrief(resume, current, prior) {
 	return lines.join("\n");
 }
 function hasPriorCoordination(prior) {
-	return prior !== void 0 && (prior.questions.length > 0 || prior.findings.length > 0 || prior.continuations.length > 0 || prior.deliveryEvidence.length > 0 || prior.records.some((record) => record.event.type === "submission"));
+	return prior !== void 0 && (prior.questions.length > 0 || prior.findings.length > 0 || prior.continuations.length > 0 || prior.deliveryEvidence.length > 0 || prior.records.length > 0);
 }
 function priorCoordinationBrief(prior) {
 	const lines = [
@@ -4623,4 +4681,4 @@ function safeJson(v) {
 //#endregion
 export { createCoordinationTools as A, withCoordinationAwaitFence as B, applyRunCancellation as C, analystToolGroupNames as D, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as E, questionEscalationTargets as F, defaultToolDetectors as H, COORDINATION_CLIENT_TOOL_TIMEOUT_MS as I, MCP_TOOL_TIMEOUT_HEADER as L, downMessageRefusalReasons as M, normalizeAnalyzeOnSettle as N, canonicalFindingEvent as O, parseAuthoredAnalystDefinition as P, declaredAwaitFenceMs as R, foldCoordinationRecords as S, ANALYST_DEFINITION_BOUNDS as T, watchTrace as U, createEventBus as V, renderAnytimeTable as _, allOf as a, withRunContext as b, createProgressTracker as c, progressStop as d, sampleFromSettled as f, plateauLength as g, bestSoFar as h, finalizeBestDelivered as i, createCoordinationToolsForManager as j, coordinationVerbNames as k, noProgressFor as l, areaUnderCurve as m, createSteerAcknowledger as n, allWorkersStalled as o, anytimeReport as p, driverAgent as r, anyOf as s, createCancelAcknowledger as t, plateau as u, createFileRunContext as v, watchRunCancellation as w, FileCoordinationLog as x, createInMemoryRunContext as y, declaredToolTimeoutMs as z };
 
-//# sourceMappingURL=coordination-driver-BTwCdKrl.js.map
+//# sourceMappingURL=coordination-driver-C3ox4-8J.js.map