@tangle-network/agent-runtime 0.202.0 → 0.203.0

package/dist/{structural-rollout-Zbntz3jo.js → structural-rollout-DPwqGLUp.js}

@@ -1525,14 +1525,28 @@ function errorMessage(error) {
 *   - `learned` — durable facts written to the cross-run `Corpus` so the NEXT
 *     run starts smarter (the continuous half of "continuous self-improvement").
 *
-* Findings are production observations (`proposal_origin:'production'`) and
-* never come from final evaluation (`derived_from_judge:false`). The observer is harness-agnostic: it
+* The default analyst produces production observations from execution evidence.
+* Injected analyses preserve their explicit proposal origins and evidence references.
+* The observer is harness-agnostic: it
 * reads a trace + an output, so it watches opencode, codex, hermes, or a BYO
 * agent identically.
 */
 const observerId = "observe/trace";
 /** The default observer instruction — exported so an optimizer can seed its population. */
 const defaultAnalystInstruction = "You are a third-person OBSERVER watching an AI agent work. You see its TRACE (what it did), not its grader. From the trace, name SPECIFIC, behavior-grounded findings: wasted/duplicated tool calls, thrash/retries, token/cost waste, missing verification, failure patterns. For each, a concrete recommended_action, and whether the AGENT (fix its skills/prompt/tools) or the OPERATOR (fix framing/decomposition/config) should act. Only claim what the trace shows. No findings if the run was clean.";
+/** Analysis can fail after paid work; its measured subtotal must remain recoverable. */
+var ObservationError = class extends Error {
+	usage;
+	constructor(message, usage, options) {
+		super(message, options);
+		this.usage = usage;
+		validateUsage(usage);
+		this.name = "ObservationError";
+	}
+};
+function validateUsage(usage) {
+	if (!Number.isSafeInteger(usage.input) || usage.input < 0 || !Number.isSafeInteger(usage.output) || usage.output < 0 || typeof usage.known !== "boolean") throw new TypeError("observation usage requires nonnegative safe integer subtotals and explicit known status");
+}
 /** Compact the trace into the lines the observer reasons over — tool calls,
 *  errors, and statuses, in order. Keeps the model call bounded + grounded. */
 function summarizeTrace(trace, maxLines) {
@@ -1609,7 +1623,9 @@ const findingsSchema = {
 	}
 };
 /** The third-person trace analyst: read a worker's trace and produce steer findings for the next attempt plus durable `learned` facts for the cross-run corpus. */
-async function observe(input, opts) {
+async function analyzeWithProfile(input, opts) {
+	if (opts.proposalOrigin !== void 0 && !["production", "search"].includes(opts.proposalOrigin)) throw new TypeError("observer proposal origin must be production or search");
+	for (const limit of [opts.maxTraceLines, opts.maxOutputChars]) if (limit !== void 0 && (!Number.isSafeInteger(limit) || limit < 0)) throw new TypeError("observer context limits must be nonnegative safe integers");
 	const traceSummary = summarizeTrace(input.trace, opts.maxTraceLines ?? 80);
 	const res = await profileChatClient({
 		profile: opts.profile,
@@ -1619,58 +1635,79 @@ async function observe(input, opts) {
 		jsonSchema: findingsSchema,
 		messages: [{
 			role: "user",
-			content: `TASK: ${input.task}\n\nOUTCOME: ${input.outcome ?? "unknown"}\n\nFINAL OUTPUT (truncated):\n${input.output.slice(0, 1200)}\n\nTRACE (in order; "xN" = repeated):\n${traceSummary}`
+			content: `TASK: ${input.task}\n\nOUTCOME: ${input.outcome ?? "unknown"}\n\nFINAL OUTPUT:\n${input.output.slice(0, opts.maxOutputChars ?? 1200)}\n\nTRACE (in order; "xN" = repeated):\n${traceSummary}`
 		}]
 	}, { ...opts.signal ? { signal: opts.signal } : {} });
-	const parsed = parseFindings(res.content);
-	const producedAt = input.runId ? `${input.runId}` : observerId;
-	const findings = assertProposalFindings(parsed.map((f) => makeProposalFinding({
-		analyst_id: observerId,
-		area: f.area,
-		severity: f.severity,
-		claim: f.claim,
-		recommended_action: f.recommended_action,
-		confidence: f.confidence,
-		evidence_refs: [],
-		derived_from_judge: false,
-		proposal_origin: "production",
-		metadata: { audience: f.audience },
-		...input.runId ? { subject: input.runId } : {}
-	})), "observe findings");
-	const learned = [];
-	if (opts.corpus) for (const f of findings) {
-		const record = {
-			schemaVersion: "1.0.0",
-			id: f.finding_id,
-			runId: input.runId ?? observerId,
-			producedAt: f.produced_at ?? producedAt,
+	const inputTokens = res.usage?.promptTokens;
+	const outputTokens = res.usage?.completionTokens;
+	const usage = {
+		input: inputTokens ?? 0,
+		output: outputTokens ?? 0,
+		known: res.usage?.captured !== false && typeof inputTokens === "number" && typeof outputTokens === "number"
+	};
+	validateUsage(usage);
+	try {
+		const findings = assertProposalFindings(parseFindings(res.content).map((f) => makeProposalFinding({
+			analyst_id: observerId,
 			area: f.area,
-			claim: f.recommended_action ?? f.claim,
-			...f.claim ? { rationale: f.claim } : {},
-			tags: [...opts.tags ?? [], `audience:${f.metadata?.audience ?? "agent"}`],
+			severity: f.severity,
+			claim: f.claim,
+			recommended_action: f.recommended_action,
 			confidence: f.confidence,
-			evidence: [{
-				kind: "finding",
-				uri: f.finding_id
-			}]
+			evidence_refs: [...input.evidenceRefs ?? []],
+			derived_from_judge: false,
+			proposal_origin: opts.proposalOrigin ?? "production",
+			metadata: { audience: f.audience },
+			...input.runId ? { subject: input.runId } : {}
+		})), "observe findings");
+		return {
+			findings: [...findings],
+			report: renderReport(findings),
+			usage
 		};
-		const r = await opts.corpus.append(record);
-		if (!r.succeeded) throw new Error(`observe corpus append failed for '${record.id}' after storing ${learned.length}/${findings.length} findings: ${r.error}`);
-		learned.push(record);
+	} catch (cause) {
+		throw new ObservationError(cause instanceof Error ? cause.message : String(cause), usage, { cause });
 	}
-	const usage = res.usage;
-	const inputTokens = usage?.promptTokens;
-	const outputTokens = usage?.completionTokens;
-	return {
-		findings: [...findings],
-		learned,
-		report: renderReport(findings),
-		usage: {
-			input: inputTokens ?? 0,
-			output: outputTokens ?? 0,
-			known: usage?.captured !== false && typeof inputTokens === "number" && typeof outputTokens === "number"
+}
+/** Analyze through the selected implementation, then retain its validated findings in the corpus. */
+async function observe(input, opts) {
+	opts.signal?.throwIfAborted();
+	const analysis = opts.analysis ? await opts.analysis(input, { ...opts.signal ? { signal: opts.signal } : {} }) : await analyzeWithProfile(input, opts);
+	validateUsage(analysis.usage);
+	const learned = [];
+	try {
+		opts.signal?.throwIfAborted();
+		const findings = assertProposalFindings(analysis.findings, "observe findings");
+		const producedAt = input.runId ?? observerId;
+		if (opts.corpus) for (const f of findings) {
+			opts.signal?.throwIfAborted();
+			const record = {
+				schemaVersion: "1.0.0",
+				id: f.finding_id,
+				runId: input.runId ?? observerId,
+				producedAt: f.produced_at ?? producedAt,
+				area: f.area,
+				claim: f.recommended_action ?? f.claim,
+				...f.claim ? { rationale: f.claim } : {},
+				tags: [...opts.tags ?? [], `audience:${f.metadata?.audience ?? "agent"}`],
+				confidence: f.confidence,
+				evidence: [{
+					kind: "finding",
+					uri: f.finding_id
+				}, ...f.evidence_refs]
+			};
+			const r = await opts.corpus.append(record);
+			if (!r.succeeded) throw new Error(`observe corpus append failed for '${record.id}' after storing ${learned.length}/${findings.length} findings: ${r.error}`);
+			learned.push(record);
 		}
-	};
+		return {
+			...analysis,
+			findings: [...findings],
+			learned
+		};
+	} catch (cause) {
+		throw new ObservationError(cause instanceof Error ? cause.message : String(cause), analysis.usage, { cause });
+	}
 }
 function parseFindings(content) {
 	let obj;
@@ -2803,6 +2840,6 @@ function structuralRollout(config = {}) {
 	});
 }
 //#endregion
-export { streamAgentTurn as A, observe as C, optimizerMethod as D, profileOptimizerModelCall as E, newRuntimeSession as F, nowIso as I, startOrResumeRuntimeSession as L, createSandboxPromptBackend as M, normalizeBackendStreamEvent as N, strategyAuthorMethod as O, InMemoryRuntimeSessionStore as P, touchSession as R, defaultAnalystInstruction as S, profileChatClient as T, depthStrategy as _, defaultStructuralRolloutPolicy as a, sample as b, officialChecksFromMeta as c, selectBestIndex as d, structuralRollout as f, defineStrategy as g, breadthStrategy as h, defaultExtractCandidate as i, createIterableBackend as j, collectAgentTurn as k, resolveEntrySymbol as l, adaptiveRefine as m, compareCheckOutcomes as n, filterAuthoredAsserts as o, visibleCheckScore as p, composeCheckSources as r, modelAuthoredChecks as s, canDisplace as t, sandboxCheckRunner as u, refine as v, renderReport as w, sampleThenRefine as x, runAgentic as y };
+export { collectAgentTurn as A, defaultAnalystInstruction as C, profileOptimizerModelCall as D, profileChatClient as E, InMemoryRuntimeSessionStore as F, newRuntimeSession as I, nowIso as L, createIterableBackend as M, createSandboxPromptBackend as N, optimizerMethod as O, normalizeBackendStreamEvent as P, startOrResumeRuntimeSession as R, ObservationError as S, renderReport as T, depthStrategy as _, defaultStructuralRolloutPolicy as a, sample as b, officialChecksFromMeta as c, selectBestIndex as d, structuralRollout as f, defineStrategy as g, breadthStrategy as h, defaultExtractCandidate as i, streamAgentTurn as j, strategyAuthorMethod as k, resolveEntrySymbol as l, adaptiveRefine as m, compareCheckOutcomes as n, filterAuthoredAsserts as o, visibleCheckScore as p, composeCheckSources as r, modelAuthoredChecks as s, canDisplace as t, sandboxCheckRunner as u, refine as v, observe as w, sampleThenRefine as x, runAgentic as y, touchSession as z };
 
-//# sourceMappingURL=structural-rollout-Zbntz3jo.js.map
+//# sourceMappingURL=structural-rollout-DPwqGLUp.js.map