@happyvertical/smrt-ingestion 0.55.6 → 0.55.8

package/dist/chunks/{execution-C6HJvl9e.js → execution-C7sTFXFU.js}

@@ -6341,8 +6341,12 @@ var require_ajv = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	});
 }));
 //#endregion
-//#region src/policy.ts
+//#region src/feedback-internal.ts
 var import_ajv = /* @__PURE__ */ __toESM(require_ajv(), 1);
+var feedbackActionTransaction = /* @__PURE__ */ Symbol("ingestion.feedbackActionTransaction");
+var feedbackDiscoveryContext = /* @__PURE__ */ Symbol("ingestion.feedbackDiscoveryContext");
+//#endregion
+//#region src/policy.ts
 var lists = [
 	"handlers",
 	"operations",
@@ -6665,9 +6669,15 @@ var IntakeExecutionService = class {
 		return this.tx((db) => this.discoveryContext(db, itemId, handlerId, handlerVersion, work));
 	}
 	/** Keep retention restoration outside the supplied foundation transaction. */
-	[discoveryTransaction](run, itemId, work) {
+	[discoveryTransaction](run, itemId, work, requireReview = false) {
 		return this.withRetention(() => run(async (db) => {
-			const authorize = (handlerId, handlerVersion, callback) => this.discoveryContext(db, itemId, handlerId, handlerVersion, callback);
+			const authorize = (handlerId, handlerVersion, callback) => this.discoveryContext(db, itemId, handlerId, handlerVersion, (context) => callback(context, (model, id2) => this.config.assertTarget({
+				db,
+				scope: this.scope,
+				itemId,
+				model,
+				id: id2
+			})), requireReview);
 			const result = await work(db, authorize);
 			for (const [retainedItemId, deadline] of this.retentionIntents.getStore() ?? []) {
 				const item = await this.restoreRetention(db, retainedItemId, deadline);
@@ -6676,7 +6686,11 @@ var IntakeExecutionService = class {
 			return result;
 		}));
 	}
-	async discoveryContext(db, itemId, handlerId, handlerVersion, work) {
+	async discoveryContext(db, itemId, handlerId, handlerVersion, work, requireReview = false, revalidate) {
+		const review = async () => {
+			const item = await this.item(db, itemId, true);
+			await this.access(db, item, this.handler(handlerId, handlerVersion), "review");
+		};
 		const authorize = async (callback) => {
 			const item = await this.item(db, itemId, true);
 			const handler = this.handler(handlerId, handlerVersion);
@@ -6701,16 +6715,18 @@ var IntakeExecutionService = class {
 			}
 			return callback(context);
 		};
+		if (requireReview) await review();
 		const result = await authorize(work);
-		await authorize(async () => {});
+		await authorize(revalidate ?? (async () => {}));
+		if (requireReview) await review();
 		return result;
 	}
-	async bound(db, actionId, lock = false, expired = false) {
+	async bound(db, actionId, lock = false, expired = false, proposalId) {
 		const [found] = await this.rows(db, "intake_actions", "id=?", [actionId]);
 		if (!found) throw new Error("Intake unavailable");
 		const item = await this.item(db, String(found.item_id), lock, expired);
 		const [action] = await this.rows(db, "intake_actions", "id=?", [actionId]);
-		const [proposal] = await this.rows(db, "intake_proposals", "action_id=? AND revision=?", [actionId, action.proposal_revision]);
+		const [proposal] = await this.rows(db, "intake_proposals", proposalId ? "action_id=? AND id=?" : "action_id=? AND revision=?", [actionId, proposalId ?? action.proposal_revision]);
 		if (!proposal) throw new Error("Proposal unavailable");
 		const binding = object(object(proposal.data).binding);
 		const handler = this.operation(this.handler(binding.handlerId, binding.handlerVersion));
@@ -6737,6 +6753,104 @@ var IntakeExecutionService = class {
 			state: String(bound.action.state)
 		};
 	}
+	/** Same-executor current review/evidence/target gate for the owning feedback ledger. */
+	/** Join an existing owning transaction; its outer boundary restores retention after rollback. */
+	[feedbackDiscoveryContext](db, itemId, handlerId, handlerVersion, work, revalidate) {
+		const run = (executor) => this.discoveryContext(executor, itemId, handlerId, handlerVersion, work, false, revalidate);
+		return db ? run(db) : this.tx(run);
+	}
+	[feedbackActionTransaction](actionId, reviewer, work, executor, requiredProviders, proposalId) {
+		const operation = async (db) => {
+			const load = async () => {
+				const bound = await this.bound(db, actionId, true, false, proposalId);
+				const { context, permissions } = await this.access(db, bound.item, bound.handler, reviewer ? "review" : "read");
+				if (requiredProviders?.some((provider) => !context.policy.providers.includes(provider))) throw new Error("Feedback source provider unavailable");
+				await this.verifyEvidence(db, bound);
+				for (const target of bound.binding.targetPreconditions) await context.assertTarget(target.model, target.id, bound.action.state === "succeeded" ? void 0 : target.revision);
+				if (bound.binding.plan) {
+					const plan = (await this.rows(db, "intake_plans", "item_id=? AND plan_key=?", [bound.item.id, bound.binding.plan.key])).sort((a, b) => Number(b.revision) - Number(a.revision))[0];
+					if (!plan || plan.digest !== bound.binding.plan.digest) throw new Error("Plan superseded");
+					const data2 = object(plan.data);
+					await this.discoveryContext(db, String(bound.item.id), String(data2.handlerId), String(data2.handlerVersion), async (parent) => {
+						for (const target of object(data2.preview).targetPreconditions) await parent.assertTarget(target.model, target.id, bound.action.state === "succeeded" ? void 0 : target.revision);
+					}, reviewer);
+				}
+				const [analysis] = await this.rows(db, "intake_analyses", "id=?", [bound.proposal.analysis_id]);
+				const [attempt] = await this.rows(db, "intake_analysis_attempts", "id=?", [bound.proposal.analysis_attempt_id]);
+				if (!analysis || !attempt || analysis.current_attempt_id !== attempt.id) throw new Error("Stale feedback source");
+				const data = object(attempt.data);
+				const result2 = {
+					status: data.status,
+					provider: data.provider,
+					model: data.model,
+					version: data.version,
+					output: data.output,
+					usage: data.usage,
+					...Object.hasOwn(data, "error") ? { error: data.error } : {},
+					...Object.hasOwn(data, "confidence") ? { confidence: data.confidence } : {}
+				};
+				if (intakeBindingDigest(result2) !== attempt.output_digest) throw new Error("Analysis output integrity");
+				const input = object(analysis.data);
+				if (intakeBindingDigest({
+					inputs: input.inputs,
+					configuration: input.configuration
+				}) !== analysis.input_digest) throw new Error("Analysis input integrity");
+				if (!this.retained(bound.item)) throw new Error("Feedback unavailable");
+				return {
+					db,
+					context,
+					permissions,
+					review: this.review(bound),
+					itemId: String(bound.item.id),
+					attemptId: String(attempt.id),
+					args: structuredClone(bound.binding.args),
+					analysis: input,
+					result: result2,
+					handlerId: bound.handler.id,
+					handlerVersion: bound.handler.version
+				};
+			};
+			const before = await load();
+			const result = await work(before);
+			const after = await load();
+			if (intakeBindingDigest(before.review) !== intakeBindingDigest(after.review)) throw new Error("Feedback binding changed");
+			if (after.permissions.some((permission) => !before.permissions.includes(permission))) throw new Error("Feedback cannot widen permissions");
+			const prior = before.context.policy, next = after.context.policy;
+			for (const key of [
+				"handlers",
+				"operations",
+				"reviewers",
+				"providers",
+				"access",
+				"automaticHandlers"
+			]) if (next[key].some((value) => !prior[key].includes(value))) throw new Error("Feedback cannot widen policy");
+			for (const key of [
+				"maxAttempts",
+				"maxSteps",
+				"maxBytes",
+				"approvalMs",
+				"leaseMs",
+				"retentionMs"
+			]) if (next[key] > prior[key]) throw new Error("Feedback cannot widen policy");
+			if (prior.requireReview && !next.requireReview || next.minimumCertainty < prior.minimumCertainty || !prior.consequentialAutomation && next.consequentialAutomation) throw new Error("Feedback cannot widen policy");
+			return result;
+		};
+		return executor ? operation(executor) : this.tx(operation);
+	}
+	async feedbackLineage(db, bound) {
+		const [attempt] = await this.rows(db, "intake_analysis_attempts", "id=?", [bound.proposal.analysis_attempt_id]);
+		if (!attempt) throw new Error("Analysis unavailable");
+		const output = object(object(attempt.data).output);
+		if (!output.proposals) return;
+		const feedback = object(object(output.proposals).provenance).feedback;
+		if (!feedback) return;
+		const references = object(object(feedback).selection).examples;
+		if (!Array.isArray(references)) throw new Error("Feedback lineage unavailable");
+		if (references.length === 0) return;
+		if (!this.options.feedback) throw new Error("Feedback configuration unavailable");
+		const { IntakeFeedbackService } = await import("./feedback-C3OHD4sA.js").then((n) => n.n);
+		await new IntakeFeedbackService(this.options, this).assertActionLineage(String(bound.action.id), db, String(bound.proposal.id));
+	}
 	async getAction(actionId) {
 		return this.tx(async (db) => {
 			const [action] = await this.rows(db, "intake_actions", "id=?", [actionId]);
@@ -6760,9 +6874,175 @@ var IntakeExecutionService = class {
 			const bound = await this.bound(db, actionId);
 			await this.access(db, bound.item, bound.handler, "read");
 			if (!this.retained(bound.item)) return expiredReview();
+			try {
+				await this.feedbackLineage(db, bound);
+			} catch (error) {
+				if (bound.action.state !== "succeeded") throw error;
+				await this.successful(db, bound.action, bound.item);
+				return {
+					...this.review(bound),
+					display: {}
+				};
+			}
 			return this.review(bound);
 		});
 	}
+	/** Bounded reload discovery. The cursor is an opaque action ID, never authority. */
+	async listReviews(itemId, input = {}) {
+		const limit = input.limit ?? 20;
+		if (!Number.isSafeInteger(limit) || limit < 1 || limit > 50 || input.cursor !== void 0 && !/^[0-9a-f-]{36}$/i.test(input.cursor)) throw new Error("Invalid review page");
+		return this.tx(async (db) => {
+			const item = await this.item(db, itemId, true, true);
+			const rows = (await db.query(`SELECT * FROM intake_actions WHERE tenant_id=? AND confidential_scope_id=? AND item_id=?${input.cursor ? " AND id>?" : ""} ORDER BY id LIMIT ?`, this.scope.tenantId, this.scope.confidentialScopeId, itemId, ...input.cursor ? [input.cursor] : [], limit + 1)).rows;
+			const actions = [];
+			let generationStale = false;
+			for (const action of rows.slice(0, limit)) {
+				const [proposal] = await this.rows(db, "intake_proposals", "action_id=? AND revision=?", [action.id, action.proposal_revision]);
+				if (!proposal) {
+					actions.push({ review: {
+						actionId: String(action.id),
+						proposalId: "",
+						revision: Number(action.proposal_revision),
+						reviewVersion: Number(action.review_version),
+						bindingHash: "",
+						display: {},
+						state: this.retained(item) ? "proposed" : "expired"
+					} });
+					continue;
+				}
+				const tombstone = (state) => ({ review: {
+					actionId: String(action.id),
+					proposalId: String(proposal.id),
+					revision: Number(proposal.revision),
+					reviewVersion: Number(action.review_version),
+					bindingHash: String(proposal.binding_hash),
+					display: {},
+					state
+				} });
+				if (!this.retained(item)) {
+					actions.push(tombstone("expired"));
+					continue;
+				}
+				const bound = await this.bound(db, String(action.id));
+				await this.access(db, bound.item, bound.handler, "read");
+				item.expires_at = bound.item.expires_at;
+				if (!this.retained(bound.item)) {
+					actions.push(tombstone("expired"));
+					continue;
+				}
+				let stale = false;
+				let recoveryAttemptId;
+				const authorizeTargets = async (targets) => {
+					for (const target of targets) if ((await this.config.assertTarget({
+						db,
+						scope: this.scope,
+						itemId,
+						model: target.model,
+						id: target.id
+					})).revision !== target.revision) {
+						generationStale = true;
+						if (bound.action.state !== "succeeded") stale = true;
+					}
+				};
+				await authorizeTargets(bound.binding.targetPreconditions);
+				if (!this.retained(bound.item)) {
+					actions.push(tombstone("expired"));
+					continue;
+				}
+				if (bound.action.state !== "succeeded") {
+					const [analysis] = await this.rows(db, "intake_analyses", "id=?", [proposal.analysis_id]);
+					if (!analysis || Number(analysis.revision) !== Number(item.analysis_revision)) stale = true;
+					else {
+						await this.verifyEvidence(db, bound);
+						const [attempt] = await this.rows(db, "intake_analysis_attempts", "id=? AND analysis_id=?", [proposal.analysis_attempt_id, analysis.id]);
+						if (attempt && ["completed", "partial"].includes(String(attempt.state)) && String(analysis.current_attempt_id) === String(attempt.id)) recoveryAttemptId = String(attempt.id);
+					}
+				}
+				const entry = {
+					review: this.review(bound),
+					args: structuredClone(bound.binding.args),
+					handlerId: bound.handler.id,
+					handlerVersion: bound.handler.version,
+					attemptId: String(proposal.analysis_attempt_id),
+					dependencies: structuredClone(bound.binding.dependencies)
+				};
+				if (action.state === "succeeded") entry.result = await this.successful(db, action, item);
+				if (bound.binding.plan) {
+					const [plan] = await this.rows(db, "intake_plans", bound.action.state === "succeeded" ? "item_id=? AND plan_key=? AND revision=?" : "item_id=? AND plan_key=? ORDER BY revision DESC LIMIT 1", bound.action.state === "succeeded" ? [
+						itemId,
+						bound.binding.plan.key,
+						bound.binding.plan.revision
+					] : [itemId, bound.binding.plan.key]);
+					if (!plan) throw new Error("Plan unavailable");
+					if (bound.action.state !== "succeeded" && Number(plan.revision) !== bound.binding.plan.revision) stale = true;
+					const planData = object(plan.data);
+					const parent = this.handler(String(planData.handlerId), String(planData.handlerVersion));
+					const parentPreview = object(planData.preview);
+					await this.discoveryContext(db, itemId, parent.id, parent.version, async () => {
+						await authorizeTargets(parentPreview.targetPreconditions);
+					});
+					const steps = planData.steps;
+					entry.plan = {
+						id: String(plan.id),
+						key: String(plan.plan_key),
+						revision: Number(plan.revision),
+						stepIndex: steps.findIndex((step) => step.actionId === action.id),
+						args: object(planData.args),
+						handlerId: parent.id,
+						handlerVersion: parent.version,
+						attemptId: String(proposal.analysis_attempt_id)
+					};
+				}
+				await this.access(db, bound.item, bound.handler, "read");
+				actions.push(!this.retained(bound.item) ? tombstone("expired") : stale ? {
+					...tombstone("stale"),
+					...recoveryAttemptId ? {
+						attemptId: recoveryAttemptId,
+						handlerId: bound.handler.id,
+						handlerVersion: bound.handler.version
+					} : {},
+					...entry.plan ? { stalePlan: {
+						id: entry.plan.id,
+						key: entry.plan.key,
+						revision: entry.plan.revision,
+						handlerId: entry.plan.handlerId,
+						handlerVersion: entry.plan.handlerVersion
+					} } : {}
+				} : entry);
+			}
+			const current = await this.item(db, itemId, false, true);
+			if (!this.retained(current)) {
+				await this.redactExecution(db, current);
+				for (let index = 0; index < actions.length; index++) actions[index] = { review: {
+					...actions[index].review,
+					display: {},
+					state: "expired"
+				} };
+			}
+			for (let index = 0; index < actions.length; index++) {
+				const entry = actions[index];
+				if (!entry.review.proposalId || entry.review.state === "expired" || entry.review.state === "stale") continue;
+				const bound = await this.bound(db, entry.review.actionId);
+				try {
+					await this.feedbackLineage(db, bound);
+				} catch (error) {
+					if (bound.action.state !== "succeeded") throw error;
+					actions[index] = {
+						review: {
+							...entry.review,
+							display: {}
+						},
+						result: await this.successful(db, bound.action, bound.item)
+					};
+				}
+			}
+			return {
+				actions,
+				...generationStale ? { generationStale: true } : {},
+				...rows.length > limit ? { nextCursor: String(rows[limit - 1].id) } : {}
+			};
+		});
+	}
 	async buildBinding(db, item, input) {
 		const handler = this.operation(this.handler(input.handlerId, input.handlerVersion));
 		const { policy, context } = await this.access(db, item, handler, "preview");
@@ -6850,6 +7130,7 @@ var IntakeExecutionService = class {
 		const replay = prior.find((row) => object(row.data).requestId === input.requestId);
 		if (replay) {
 			if (object(replay.data).requestHash !== requestHash) throw new Error("Proposal request conflict");
+			await this.feedbackLineage(db, await this.bound(db, input.actionId, false, false, String(replay.id)));
 			return {
 				actionId: input.actionId,
 				proposalId: String(replay.id),
@@ -6891,6 +7172,7 @@ var IntakeExecutionService = class {
 			})
 		});
 		await db.query("UPDATE intake_actions SET proposal_revision=?,review_version=?,state='waiting_review' WHERE id=? AND tenant_id=? AND confidential_scope_id=?", revision, reviewVersion, action.id, this.scope.tenantId, this.scope.confidentialScopeId);
+		await this.feedbackLineage(db, await this.bound(db, input.actionId, false, false, String(proposal.id)));
 		return {
 			actionId: String(action.id),
 			proposalId: String(proposal.id),
@@ -6909,6 +7191,62 @@ var IntakeExecutionService = class {
 			return this.publish(db, item, frozen, binding);
 		});
 	}
+	/** Capture owner facts in the same transaction; these are never correctness labels. */
+	async feedbackEvent(db, bound, eventId, kind) {
+		if (!this.options.feedback || !this.retained(bound.item)) return;
+		if (!await this.options.feedback.authorize({
+			db,
+			scope: this.scope,
+			itemId: String(bound.item.id),
+			operation: "capture"
+		})) return;
+		const table = kind === "action_decision" ? "intake_review_decisions" : "intake_executions";
+		const [event] = await this.rows(db, table, "id=? AND action_id=?", [eventId, bound.action.id]);
+		if (!event) throw new Error("Feedback event unavailable");
+		const eventData = object(event.data), signal = kind === "action_decision" ? event.decision : event.state;
+		const key = `event:${kind}:${eventId}:${String(signal)}`;
+		const [replay] = await this.rows(db, "intake_feedback", "item_id=? AND request_key=?", [bound.item.id, key]);
+		if (replay) return;
+		const [attempt] = await this.rows(db, "intake_analysis_attempts", "id=?", [bound.proposal.analysis_attempt_id]);
+		const provenance = object(attempt.data), generation = object(object(provenance.output).proposals ?? {});
+		const body = {
+			version: 1,
+			eventId,
+			actionId: bound.action.id,
+			proposalId: bound.proposal.id,
+			revision: Number(bound.proposal.revision),
+			bindingHash: bound.proposal.binding_hash,
+			attemptId: attempt.id,
+			attemptDigest: attempt.output_digest,
+			evidence: bound.binding.evidence,
+			handlerId: bound.handler.id,
+			handlerVersion: bound.handler.version,
+			signal,
+			reviewer: kind === "action_decision" ? eventData.reviewer : null,
+			observedBy: this.scope.actorId,
+			principalId: eventData.principalId ?? null,
+			reason: kind === "action_decision" ? eventData.reason ?? "" : "",
+			resultDigest: event.result_digest ?? null,
+			model: {
+				provider: provenance.provider,
+				model: provenance.model,
+				version: provenance.version
+			},
+			generationProvenance: generation.provenance ?? null
+		};
+		const data = {
+			...body,
+			digest: intakeBindingDigest(body)
+		};
+		if (Buffer.byteLength(canonical(data)) > this.options.feedback.maxBytes) return;
+		await this.insert(db, "intake_feedback", {
+			item_id: bound.item.id,
+			request_key: key,
+			supersedes_id: null,
+			kind,
+			data: canonical(data)
+		});
+	}
 	async submitDecision(input) {
 		const frozen = JSON.parse(canonical(input));
 		id(frozen.requestId);
@@ -6921,6 +7259,7 @@ var IntakeExecutionService = class {
 		return this.tx(async (db) => {
 			const bound = await this.bound(db, frozen.actionId, true);
 			const { policy } = await this.access(db, bound.item, bound.handler, "review");
+			await this.feedbackLineage(db, bound);
 			const decisions = await this.rows(db, "intake_review_decisions", "action_id=?", [frozen.actionId]);
 			const requestHash = intakeBindingDigest(frozen);
 			const replay = decisions.find((row) => object(row.data).requestId === frozen.requestId);
@@ -6932,7 +7271,7 @@ var IntakeExecutionService = class {
 			if (bound.action.state !== "waiting_review" || Number(bound.proposal.revision) !== frozen.expectedRevision || Number(bound.action.review_version) !== frozen.expectedReviewVersion || bound.proposal.binding_hash !== frozen.bindingHash) throw new Error("Stale review");
 			await this.verifyEvidence(db, bound);
 			const expiresAt = new Date(Math.min(time(bound.item.expires_at), this.now().getTime() + policy.approvalMs)).toISOString();
-			await this.insert(db, "intake_review_decisions", {
+			const decisionEvent = await this.insert(db, "intake_review_decisions", {
 				item_id: bound.item.id,
 				action_id: bound.action.id,
 				proposal_id: bound.proposal.id,
@@ -6950,6 +7289,7 @@ var IntakeExecutionService = class {
 					kind: "human"
 				})
 			});
+			await this.feedbackEvent(db, bound, String(decisionEvent.id), "action_decision");
 			if (frozen.decision === "correct") {
 				if (bound.binding.plan) throw new Error("Plan correction requires re-expansion");
 				if (!frozen.correctedArgs) throw new Error("Correction arguments required");
@@ -6965,8 +7305,10 @@ var IntakeExecutionService = class {
 					dependencies: bound.binding.dependencies
 				};
 				const binding = await this.buildBinding(db, bound.item, corrected);
+				await this.feedbackLineage(db, bound);
 				return this.publish(db, bound.item, corrected, binding);
 			}
+			await this.feedbackLineage(db, bound);
 			const state = {
 				approve: "authorized",
 				reject: "rejected",
@@ -6995,6 +7337,7 @@ var IntakeExecutionService = class {
 		}
 	}
 	async approved(db, bound) {
+		await this.feedbackLineage(db, bound);
 		await this.verifyEvidence(db, bound);
 		if (bound.binding.plan) {
 			const latest = (await this.rows(db, "intake_plans", "item_id=? AND plan_key=?", [bound.item.id, bound.binding.plan.key])).sort((a, b) => Number(b.revision) - Number(a.revision))[0];
@@ -7053,6 +7396,7 @@ var IntakeExecutionService = class {
 			const access = await this.access(db, bound.item, bound.handler, "execute");
 			const consequential = bound.handler.execution.kind === "external" || bound.handler.capability.effect === "destructive" || bound.handler.capability.openWorld;
 			if (!access.policy.automaticHandlers.includes(bound.handler.id) || consequential && !access.policy.consequentialAutomation || !this.config.evaluateAutomatic) throw new Error("Automatic eligibility revoked");
+			await this.feedbackLineage(db, bound);
 			const evaluated = await this.config.evaluateAutomatic({
 				bindingHash: String(bound.proposal.binding_hash),
 				handlerId: bound.handler.id,
@@ -7062,6 +7406,7 @@ var IntakeExecutionService = class {
 		}
 		if (time(object(decision.data).expiresAt) <= this.now().getTime()) throw new Error("Approval required");
 		await this.verifyEvidence(db, bound);
+		await this.feedbackLineage(db, bound);
 		return Math.min(time(decisionData.expiresAt), time(bound.item.expires_at));
 	}
 	async arguments(db, bound, context) {
@@ -7169,6 +7514,7 @@ var IntakeExecutionService = class {
 		};
 		if (!(await db.query("UPDATE intake_actions SET state='succeeded',result_digest=? WHERE id=? AND tenant_id=? AND confidential_scope_id=? AND fence=? AND state IN ('executing','outcome_unknown') RETURNING id", resultDigest, bound.action.id, this.scope.tenantId, this.scope.confidentialScopeId, execution.fence)).rows.length) throw new Error("Execution fence lost");
 		await db.query("UPDATE intake_executions SET state='succeeded',result_digest=?,data=? WHERE id=? AND tenant_id=? AND confidential_scope_id=?", resultDigest, canonical(data), execution.id, this.scope.tenantId, this.scope.confidentialScopeId);
+		await this.feedbackEvent(db, bound, String(execution.id), "downstream_outcome");
 		return {
 			state: "succeeded",
 			actionId: String(bound.action.id),
@@ -7212,6 +7558,7 @@ var IntakeExecutionService = class {
 				};
 				await db.query("UPDATE intake_actions SET state='outcome_unknown' WHERE id=? AND tenant_id=? AND confidential_scope_id=?", actionId, this.scope.tenantId, this.scope.confidentialScopeId);
 				await db.query("UPDATE intake_executions SET state='outcome_unknown' WHERE id=? AND tenant_id=? AND confidential_scope_id=?", execution2.id, this.scope.tenantId, this.scope.confidentialScopeId);
+				await this.feedbackEvent(db, bound2, String(execution2.id), "downstream_outcome");
 				return {
 					state: "outcome_unknown",
 					actionId
@@ -7222,6 +7569,7 @@ var IntakeExecutionService = class {
 			return this.principal(db, bound2.item, bound2.handler, "execute", async (context) => {
 				if (Number(bound2.action.execution_attempt) >= context.policy.maxAttempts) throw new Error("Execution budget exceeded");
 				const args = await this.arguments(db, bound2, context);
+				await this.feedbackLineage(db, bound2);
 				const attemptNumber = Number(bound2.action.execution_attempt) + 1;
 				const fence = Number(bound2.action.fence) + 1;
 				const execution2 = await this.insert(db, "intake_executions", {
@@ -7277,6 +7625,7 @@ var IntakeExecutionService = class {
 						error: "domain_failure",
 						rolledBack: true
 					} : {}), execution2.id, this.scope.tenantId, this.scope.confidentialScopeId);
+					await this.feedbackEvent(db, bound2, String(execution2.id), "downstream_outcome");
 					await db.query("UPDATE intake_actions SET state='failed' WHERE id=? AND tenant_id=? AND confidential_scope_id=?", actionId, this.scope.tenantId, this.scope.confidentialScopeId);
 					return {
 						state: "failed",
@@ -7340,6 +7689,10 @@ var IntakeExecutionService = class {
 				if (!this.retained(item)) await this.redactExecution(db, item);
 				await db.query("UPDATE intake_actions SET state='outcome_unknown' WHERE id=? AND tenant_id=? AND confidential_scope_id=? AND fence=? AND state='executing'", actionId, this.scope.tenantId, this.scope.confidentialScopeId, execution.fence);
 				await db.query("UPDATE intake_executions SET state='outcome_unknown' WHERE id=? AND tenant_id=? AND confidential_scope_id=? AND state='claimed'", execution.id, this.scope.tenantId, this.scope.confidentialScopeId);
+				await this.feedbackEvent(db, {
+					...bound,
+					item
+				}, String(execution.id), "downstream_outcome");
 				return {
 					state: "outcome_unknown",
 					actionId,
@@ -7393,6 +7746,10 @@ var IntakeExecutionService = class {
 				...object(execution.data),
 				reconciliation: observed.kind
 			}), execution.id, this.scope.tenantId, this.scope.confidentialScopeId);
+			await this.feedbackEvent(db, {
+				...bound,
+				item
+			}, String(execution.id), "downstream_outcome");
 			return {
 				state,
 				actionId,
@@ -7407,12 +7764,14 @@ var IntakeExecutionService = class {
 			const { current, policy, context } = await this.access(db, bound.item, bound.handler, "execute");
 			const consequential = bound.handler.execution.kind === "external" || bound.handler.capability.effect === "destructive" || bound.handler.capability.openWorld;
 			if (bound.action.state !== "waiting_review" || !policy.automaticHandlers.includes(bound.handler.id) || consequential && !policy.consequentialAutomation || !this.config.evaluateAutomatic) throw new Error("Automatic execution unavailable");
+			await this.feedbackLineage(db, bound);
 			const evaluated = await this.config.evaluateAutomatic({
 				bindingHash: String(bound.proposal.binding_hash),
 				handlerId: bound.handler.id,
 				context
 			});
 			if (!evaluated.eligible || !Number.isFinite(evaluated.certainty) || evaluated.certainty < policy.minimumCertainty || evaluated.certainty > 1 || current.policy.filter((layer, index) => index < 3 || layer.automation !== void 0).some((layer) => layer.automation?.evaluationVersion !== evaluated.evaluationVersion)) throw new Error("Automatic execution unavailable");
+			await this.feedbackLineage(db, bound);
 			await this.verifyEvidence(db, bound);
 			if (!this.retained(bound.item)) throw new RetentionExpired(String(bound.item.id), time(bound.item.expires_at));
 			await this.insert(db, "intake_review_decisions", {
@@ -7471,7 +7830,11 @@ var IntakeExecutionService = class {
 					key: frozen.planKey,
 					revision: Number(replay.revision),
 					digest: String(replay.digest),
-					steps: await Promise.all(steps.map(async (step) => this.review(await this.bound(db, step.actionId))))
+					steps: await Promise.all(steps.map(async (step) => {
+						const bound = await this.bound(db, step.actionId);
+						await this.feedbackLineage(db, bound);
+						return this.review(bound);
+					}))
 				};
 			}
 			if (Math.max(0, ...existing.map((plan2) => Number(plan2.revision))) !== frozen.expectedRevision) throw new Error("Plan conflict");
@@ -7600,6 +7963,7 @@ var IntakeExecutionService = class {
 					}))
 				})
 			});
+			for (const review of reviews) await this.feedbackLineage(db, await this.bound(db, review.actionId, false, false, review.proposalId));
 			return {
 				id: String(plan.id),
 				key: frozen.planKey,
@@ -7662,6 +8026,6 @@ async function continueIntakeReview(service, actionId, task) {
 	return service.applyAction(actionId);
 }
 //#endregion
-export { require_ajv as a, resolveIntakePolicy as i, continueIntakeReview as n, __toESM as o, intakeBindingDigest as r, IntakeExecutionService as t };
+export { feedbackActionTransaction as a, __exportAll as c, resolveIntakePolicy as i, __toESM as l, continueIntakeReview as n, feedbackDiscoveryContext as o, intakeBindingDigest as r, require_ajv as s, IntakeExecutionService as t };
 
-//# sourceMappingURL=execution-C6HJvl9e.js.map
+//# sourceMappingURL=execution-C7sTFXFU.js.map