@happyvertical/smrt-ingestion 0.57.20 → 0.57.21

package/agents/execution.md

@@ -83,6 +83,21 @@ each step review; changed preview/preconditions require a fresh review.
 Abort/continue follows the pinned public playbook definition, with fresh authority
 at every step.
 
+Human corrections are the logical split and the reviewer instruction. Both are
+minted only by their authenticated review API under reviewer authority, written
+into a new immutable extraction configuration, and reach interpretation only as
+a digest-verified copy. Neither grants handlers, candidates, permissions or
+automation; `authorizeAutomatic` and preview/approval are unchanged for actions
+produced under an instruction. Recording either supersedes current suggestions
+and queues the existing dispatch stages (a new extraction revision, then
+interpretation — provider extraction budget is spent per correction because the
+predecessor pin is not reused); hosts wake their worker through
+`onSplit`/`onInstruct` and rely on dispatch repair otherwise. While a stage is
+queued/running the item reports `processing` regardless of earlier actions; a
+failed stage (extraction or interpretation) exposes its safe category through
+`getReinterpretationState`, and a retry anchored on the latest completed
+generation carries forward any newer split correction.
+
 `continueIntakeReview` uses the existing jobs continuation context. Applications
 create tasks with owner, tenant and exact `{recordId, revision, inputKey}` binding
 and configure `authorizeMcpTask` to revalidate it. A continuation answer only wakes

package/dist/chunks/{execution-NoDh3pjs.js → execution-9CfjxX8I.js}

@@ -1,4 +1,3 @@
-import { t as discoveryTransaction } from "./execution-internal-DWteDHM2.js";
 import { ObjectRegistry, detectEngine, isEmbeddedDatabase, withEmbeddedWriteTransaction } from "@happyvertical/smrt-core";
 import { createHash, randomUUID } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -45,6 +44,31 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 //#endregion
+//#region src/execution-internal.ts
+var discoveryTransaction = /* @__PURE__ */ Symbol("ingestion.discoveryTransaction");
+var generationSnapshotRead = /* @__PURE__ */ Symbol("ingestion.generationSnapshotRead");
+var listReadGate = /* @__PURE__ */ Symbol("ingestion.listReadGate");
+//#endregion
+//#region src/proposal-errors.ts
+var HandlerArgumentsInvalidError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "HandlerArgumentsInvalidError";
+	}
+};
+var GenerationSourceStaleError = class extends Error {
+	constructor() {
+		super("Generation source superseded");
+		this.name = "GenerationSourceStaleError";
+	}
+};
+var GenerationSnapshotStaleError = class extends Error {
+	constructor() {
+		super("Generation snapshot stale");
+		this.name = "GenerationSnapshotStaleError";
+	}
+};
+//#endregion
 //#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/code.js
 var require_code$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
@@ -6583,26 +6607,53 @@ var IntakeExecutionService = class {
 		].includes(handler.capability.effect ?? "") || typeof handler.capability.idempotent !== "boolean" || typeof handler.capability.openWorld !== "boolean") throw new Error("Undeclared capability");
 		return handler;
 	}
-	validate(schema, value, limit) {
+	/**
+	* `arguments` marks arguments being previewed (operation preview, which
+	* also carries corrections, and plan preview): only their schema refusal is
+	* the correctable `HandlerArgumentsInvalidError`. Apply-time and
+	* external-send revalidation and result-schema checks keep the plain error.
+	*/
+	validate(schema, value, limit, arguments_ = false) {
 		if (Buffer.byteLength(canonical(value)) > limit || schema.type !== "object" || schema.additionalProperties !== false) throw new Error("Invalid handler payload");
-		if (!this.ajv.compile(schema)(value)) throw new Error("Invalid handler payload");
+		if (!this.ajv.compile(schema)(value)) throw arguments_ ? new HandlerArgumentsInvalidError("Invalid handler payload") : /* @__PURE__ */ new Error("Invalid handler payload");
 	}
-	async access(db, item, handler, operation) {
+	/**
+	* The read-only half of `access`: current host authority, policy and
+	* ceiling allowlists and the retention deadline they imply. It writes
+	* nothing, so a listing may call it per (item, handler) without opening a
+	* transaction per row.
+	*/
+	async authority(db, item, handler, operation, onHostError) {
 		const ceiling = this.ceiling(item);
-		const current = await this.config.authorize({
-			db,
-			scope: this.scope,
-			itemId: String(item.id),
-			capturedCeiling: ceiling,
-			operation,
-			handlerId: handler.id
-		});
+		let current;
+		try {
+			current = await this.config.authorize({
+				db,
+				scope: this.scope,
+				itemId: String(item.id),
+				capturedCeiling: ceiling,
+				operation,
+				handlerId: handler.id
+			});
+		} catch (error) {
+			onHostError?.(error);
+			throw error;
+		}
 		if (!current.allowed || current.mutationBoundary !== "serialized" || current.principalId !== ceiling.principalId) throw new Error("Intake unavailable");
 		const policy = resolveIntakePolicy(current.policy);
 		const operationKey = "model" in handler.operation ? `${handler.operation.model}:${handler.operation.action}@${handler.operation.version}` : handler.operation.playbookKey;
 		if (!policy.enabled || !policy.handlers.includes(handler.id) || !ceiling.handlers.includes(handler.id) || !policy.operations.includes(operationKey) || !ceiling.operations.includes(operationKey) || !policy.access.includes(this.scope.confidentialScopeId)) throw new Error("Intake unavailable");
 		if (operation === "review" && (!current.reviewer || !policy.reviewers.includes(this.scope.actorId))) throw new Error("Intake unavailable");
 		const deadline = Math.min(time(item.expires_at), time(item.created_at) + policy.retentionMs);
+		return {
+			current,
+			ceiling,
+			policy,
+			deadline
+		};
+	}
+	async access(db, item, handler, operation) {
+		const { current, ceiling, policy, deadline } = await this.authority(db, item, handler, operation);
 		const enforce = async (executor) => {
 			const intents = this.retentionIntents.getStore();
 			const itemId = String(item.id);
@@ -6739,6 +6790,38 @@ var IntakeExecutionService = class {
 			handler
 		};
 	}
+	/**
+	* Read authority for one handler binding of a listed item, read-only. It
+	* applies the handler checks `listReviews` applies before projecting an
+	* action: the bound handler must resolve to a single operation whose
+	* operation and capability still match the saved binding (no version
+	* drift), and the execution read gate (host authority, policy and ceiling
+	* handler/operation allowlists, `policy.access`, principal) must pass, but
+	* without the retention write; an item past the deadline `access` would
+	* narrow to is not listable, and neither is a cancelled item, which
+	* `listReviews` refuses once it binds an action. Per-action target,
+	* evidence and plan gates are not evaluated here; `load` still enforces
+	* them. A refusal or any other failed check answers false and the list
+	* discloses nothing about why; a host `authorize` that throws propagates,
+	* as it does from `load`, so the page is rejected. Package-internal:
+	* reachable only through a symbol the service holds,
+	* so callers cannot hand it an unscoped row.
+	*/
+	async [listReadGate](item, binding) {
+		let hostFailure;
+		try {
+			if (item.cancelled) return false;
+			const handler = this.operation(this.handler(binding.handlerId, binding.handlerVersion));
+			if (canonical(handler.operation) !== canonical(binding.operation) || canonical(handler.capability) !== canonical(binding.capability)) return false;
+			const { deadline } = await this.authority(this.db, item, handler, "read", (error) => {
+				hostFailure = { error };
+			});
+			return deadline > this.now().getTime();
+		} catch {
+			if (hostFailure) throw hostFailure.error;
+			return false;
+		}
+	}
 	review(bound) {
 		return {
 			actionId: String(bound.action.id),
@@ -6848,7 +6931,7 @@ var IntakeExecutionService = class {
 		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-CJB900iG.js").then((n) => n.r);
+		const { IntakeFeedbackService } = await import("./feedback-CuUzWKzP.js").then((n) => n.r);
 		await new IntakeFeedbackService(this.options, this).assertActionLineage(String(bound.action.id), db, String(bound.proposal.id));
 	}
 	async getAction(actionId) {
@@ -7043,7 +7126,12 @@ var IntakeExecutionService = class {
 			};
 		});
 	}
-	async buildBinding(db, item, input) {
+	/**
+	* `reviewed` marks arguments a reviewer is previewing or correcting: only
+	* then is a refusal the typed `HandlerArgumentsInvalidError`. Apply-time
+	* verification and plan step expansion keep the plain error.
+	*/
+	async buildBinding(db, item, input, reviewed = false) {
 		const handler = this.operation(this.handler(input.handlerId, input.handlerVersion));
 		const { policy, context } = await this.access(db, item, handler, "preview");
 		const dependencies = input.dependencies ?? {};
@@ -7073,8 +7161,8 @@ var IntakeExecutionService = class {
 			}
 			concrete[field] = `00000000-0000-4000-8000-000000000000`;
 		}
-		this.validate(handler.argsSchema, concrete, policy.maxBytes);
-		if (!(await handler.validate(input.args, context)).ok) throw new Error("Invalid handler arguments");
+		this.validate(handler.argsSchema, concrete, policy.maxBytes, reviewed);
+		if (!(await handler.validate(input.args, context)).ok) throw reviewed ? new HandlerArgumentsInvalidError("Invalid handler arguments") : /* @__PURE__ */ new Error("Invalid handler arguments");
 		const preview = await handler.preview(input.args, context);
 		if (canonical(preview.normalizedArgs) !== canonical(input.args)) throw new Error("Preview arguments must be normalized before publication");
 		for (const target of preview.targetPreconditions) await context.assertTarget(target.model, target.id, target.revision);
@@ -7187,7 +7275,7 @@ var IntakeExecutionService = class {
 		const frozen = JSON.parse(canonical(input));
 		return this.tx(async (db) => {
 			const item = await this.item(db, frozen.itemId, true);
-			const binding = await this.buildBinding(db, item, frozen);
+			const binding = await this.buildBinding(db, item, frozen, true);
 			return this.publish(db, item, frozen, binding);
 		});
 	}
@@ -7304,7 +7392,7 @@ var IntakeExecutionService = class {
 					args: frozen.correctedArgs,
 					dependencies: bound.binding.dependencies
 				};
-				const binding = await this.buildBinding(db, bound.item, corrected);
+				const binding = await this.buildBinding(db, bound.item, corrected, true);
 				await this.feedbackLineage(db, bound);
 				return this.publish(db, bound.item, corrected, binding);
 			}
@@ -7803,8 +7891,8 @@ var IntakeExecutionService = class {
 			const handler = this.handler(frozen.handlerId, frozen.handlerVersion);
 			if (!("expand" in handler) || !("playbookKey" in handler.operation)) throw new Error("Playbook handler required");
 			const { policy, context } = await this.access(db, item, handler, "preview");
-			this.validate(handler.argsSchema, frozen.args, policy.maxBytes);
-			if (!(await handler.validate(frozen.args, context)).ok) throw new Error("Invalid plan arguments");
+			this.validate(handler.argsSchema, frozen.args, policy.maxBytes, true);
+			if (!(await handler.validate(frozen.args, context)).ok) throw new HandlerArgumentsInvalidError("Invalid plan arguments");
 			const preview = await handler.preview(frozen.args, context);
 			if (canonical(preview.normalizedArgs) !== canonical(frozen.args) || Buffer.byteLength(canonical(preview)) > policy.maxBytes) throw new Error("Invalid plan preview");
 			for (const target of preview.targetPreconditions) await context.assertTarget(target.model, target.id, target.revision);
@@ -8024,6 +8112,6 @@ async function continueIntakeReview(service, actionId, task) {
 	return service.applyAction(actionId);
 }
 //#endregion
-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 };
+export { feedbackActionTransaction as a, GenerationSnapshotStaleError as c, discoveryTransaction as d, generationSnapshotRead as f, __toESM as h, resolveIntakePolicy as i, GenerationSourceStaleError as l, __exportAll as m, continueIntakeReview as n, feedbackDiscoveryContext as o, listReadGate as p, intakeBindingDigest as r, require_ajv as s, IntakeExecutionService as t, HandlerArgumentsInvalidError as u };
 
-//# sourceMappingURL=execution-NoDh3pjs.js.map
+//# sourceMappingURL=execution-9CfjxX8I.js.map