@happyvertical/smrt-ingestion 0.57.26 → 0.57.27

package/FEEDBACK.md

@@ -38,6 +38,13 @@ decision by that actor, never as reviewer correctness evidence; consumers that
 derive reviewer agreement must exclude `selfDecision: true` events, and nothing
 in this package turns them into automation eligibility.
 
+Generated-output validity is not a feedback signal. A suggestion kept because
+its arguments missed only required fields (#4284, PROPOSALS.md) is recorded as
+incomplete — `needs_review` with those fields in `missingFields` — not as an
+invalid reply with a `provenance.failure`. It produces no feedback record by
+itself; only the reviewer's explicit judgment or approval of the completed
+arguments does, through the paths above.
+
 ## Reviewer routing choices
 
 A `reviewer_routing` record is appended inside the owning transaction when

package/PROPOSALS.md

@@ -115,6 +115,36 @@ without automatic retry that would bypass application boundary checks. The
 adapter's public identity is exactly provider/model/version; credentials and raw
 provider errors are never provenance.
 
+The fixed system instruction (`proposalInstructions`, extended per item by
+`proposalInstructionsFor` with the handler argument contract and split
+eligibility) is generic and value-free. It treats evidence as untrusted data,
+never instructions, and limits suggestions to offered handlers and candidates.
+It asks the model to fill every argument readable from the evidence
+(identifiers, numbers, dates, quantities, amounts and currency) in the form its
+schema requires, never inventing a value the evidence does not show; a value
+that cannot be expressed in that form is treated as absent. Each value must be
+the one whose label or context matches the field's name and description; when
+several similar values appear, a field whose named value is missing is treated
+as absent rather than given a substitute. A candidate reference is chosen only
+from that handler's listed candidates, and an evidence reference copies the
+supplied `evidenceId`. `missingFields` lists exactly the required fields left
+out of `args`, and a required field is left out only when its value is genuinely
+absent or no offered candidate matches. On required-only schema refusals, the
+validator computes the absent required set and corrects a mismatched model
+declaration; the instruction guides the model without making its declaration
+authoritative. Absent optional fields stay out
+of both `args` and `missingFields`. The model prefers `no_action` when no
+offered handler's description fits the document's role, and `unknown` when the
+evidence cannot be interpreted (#4290). Domain routing, such as which received
+documents an application ignores, belongs in host handler descriptions or
+reviewer guidance, not in this text. The text is not persisted. It is not part
+of the frozen interpretation configuration, the input, catalog or output
+digests, or the stored generation output, so a package release that changes it
+leaves stored attempts readable and previewable unchanged. New attempts send the
+new text, but their digests do not record it; a host that needs provenance to
+tell the two apart bumps its own `promptVersion`, which, like any configuration
+change, makes earlier attempts read as stale (`GenerationSnapshotStaleError`).
+
 A trusted custom `ProposalGenerator` must likewise honor cancellation, bound its
 response, and explicitly declare validated `complete` or `unknown` completion.
 The SDK currently normalizes missing/unknown finish reasons to `stop`
@@ -156,11 +186,44 @@ Model output can contain only offered handler versions, schema-valid arguments,
 retained evidence locations and offered alternative handler/candidate keys.
 Candidate IDs must occur in the offered set, and evidence IDs in retained source
 results. Unknown enums, invented IDs, extra authority/tool/approval fields and
-malformed structures fail closed. Missing required top-level fields are retained
-as `missingFields`, with `needs_review`; values are never invented to satisfy a
+malformed structures fail closed. Missing required fields are retained as
+`missingFields`, with `needs_review`; values are never invented to satisfy a
 schema. Observed page/time/source granularity is preserved. Logical scan splits
 use `proposeDocumentSplits`; originals and hashes remain intact.
 
+When a suggestion's arguments fail the handler schema **only** on `required`
+(#4284), the suggestion is kept rather than rejecting the attempt: its
+arguments stay exactly as generated and `missingFields` names every missing
+required argument. The schema, not the model, decides what is missing. A
+declaration that matches the computed set (in any order) is kept exactly as the
+model wrote it, so an already valid reply is unchanged byte for byte and replay
+stays deterministic. A declaration that differs (unlisted misses, or listed
+fields that are present or optional) is replaced by the sorted computed set and
+the suggestion is `needs_review` even when nothing is left missing;
+`provenance.missingFieldsCorrection` then records `{suggestions, added,
+removed}` counts only, and is absent otherwise and dropped whenever the
+suggestions are discarded. A miss at the
+argument root is the bare property name; a miss inside a present nested object
+or array item is an RFC 6901 JSON Pointer relative to the arguments, such as
+`/vendor/name` or `/lines/0/sku`. An entry starting with `/` is therefore a
+pointer, so a handler should not declare a root property whose name itself
+starts with `/`. Names come from the handler schema's own `required` lists,
+never from argument values or model-chosen keys; `required` inside `allOf` or
+inside object-form `dependencies` (`{a: {required: ['b']}}`) counts like any
+other. The schema walk does not follow `$ref`: a miss directly at a property
+whose schema is a `$ref` is kept, but a miss deeper inside the referenced
+definition cannot be named from the schema and rejects (fail-safe). The attempt still rejects as before when any other
+keyword fails beside or instead of `required`: type, enum, pattern, bounds,
+`additionalProperties`, an `anyOf`/`oneOf` branch, an `if`/`then`/`else` branch
+(Ajv adds an `if` error), `not`, or array-form `dependencies` (its own keyword,
+although it names the missing property). It also rejects when a miss lies under
+a key the schema does not declare, or when more than 30 fields are missing.
+Handler schemas compile in Ajv strict mode, so draft-2019 keywords such as
+`dependentRequired` are refused at compile time. Such a suggestion is ordinary
+`needs_review` output: the decision gate can only withhold readiness, never
+grant it, `automaticActionEligible` stays false, and generated preview of
+incomplete arguments fails the handler schema (see Explicit preview below).
+
 A generated split whose groups fail that check is dropped, not the whole reply
 (#4288): the suggestions and any other splits are validated as before, the
 dropped split is never published or applied, and `provenance.splitsDropped`
@@ -371,7 +434,10 @@ Selections must reference current persisted validated `ready_for_review` or
 `needs_review` output (#4208); a `provider_error` attempt, an unoffered handler or
 a non-interpretation stage is rejected. A `needs_review` suggestion whose
 `missingFields` are still absent fails the handler schema inside the ordinary
-preview (`Invalid handler payload`) and publishes nothing; the reviewer supplies
+preview (`HandlerArgumentsInvalidError`, `Invalid handler payload`, whose
+value-free `issues` name the missing schema fields, for example
+`{ path: '/title', keyword: 'required' }`; see REVIEW.md) and publishes
+nothing; the reviewer supplies
 the missing values through the explicit human path (`previewProposal` /
 `previewPlan`, as the published review host does for `preview({args})`), and the
 handler's `validate` and `preview` run again on the completed arguments.

package/README.md

@@ -210,7 +210,10 @@ Reviewers can start any offered handler for an item (`startReviewerAction`) or
 close it as handled without action (`resolveItem`); the published host adapter
 wires both as `startAction`/`resolve` and exposes the offered `catalog`. Hosts
 with their own transport add the two POST operations behind the same session,
-CSRF and reviewer checks as `decide`. The `intake_dispositions` table requires
+CSRF and reviewer checks as `decide`, and map a thrown
+`HandlerArgumentsInvalidError` (name and value-free `issues`) from `startAction`
+exactly as they do for `preview` so the form stays inline (see
+[REVIEW.md](REVIEW.md)). The `intake_dispositions` table requires
 a manifest migration before upgrading.
 
 ## Recipe preview

package/REVIEW.md

@@ -35,7 +35,9 @@ Plan membership contains the exact parent args/version so edits call
 `previewPlan`, not per-step correction. An item may have more review pages; the
 host must aggregate state across pages when projecting a production inbox state.
 
-A `needs_review` suggestion is completable, not only rejectable (#4208). The
+A `needs_review` suggestion is completable, not only rejectable (#4208). That
+includes a suggestion kept because its arguments missed only required fields
+(#4284); nested misses appear as JSON Pointers such as `/vendor/name`. The
 component shows its `missingFields`, an editable `Suggested arguments (JSON)`
 draft prefilled from the generated arguments, and the candidate picker for
 declared candidate fields; Prepare review stays disabled while required fields
@@ -45,21 +47,49 @@ which the published host publishes through the ordinary `previewProposal` /
 `previewPlan` with the same `ui:<index>` intention, never by rewriting the
 generation. The handler validates the human arguments again before a
 `waiting_review` action exists, approval remains a separate explicit decision,
-`ActionReview` lists required arguments missing from the current draft while
-editing, and no authority or automation eligibility is added: a failed attempt,
+`ActionReview` lists top-level required arguments missing from the current
+draft while editing (nested misses named by JSON Pointer in `missingFields` are
+not re-checked in the browser; the server's revalidation refuses them and the
+component shows that inline as `HandlerArgumentsInvalidError`), and no authority or automation eligibility is added: a failed attempt,
 an unoffered handler or a foreign stage is still refused by the host.
 `preview` throws on every failure, as before. When the handler's argument
 schema or `validate` refused the arguments being previewed (operation preview,
-which also carries corrections, or plan preview), the server throws
-`HandlerArgumentsInvalidError` (`name` set, messages unchanged). Apply-time and
+which also carries corrections, a reviewer-started action, or plan preview),
+the server throws `HandlerArgumentsInvalidError` (`name` set, messages
+unchanged). An argument-schema refusal also carries `issues`: a frozen list of
+at most `HANDLER_ARGUMENT_ISSUE_LIMIT` (20) `{ path, keyword? }` entries
+(`HandlerArgumentIssue`). `path` is built only from schema-declared property
+names, `required` names and real array indexes and is cut at
+`HANDLER_ARGUMENT_PATH_LIMIT` (160)
+characters (never splitting a `~0`/`~1` escape). Segments are escaped per RFC
+6901 (`~` as `~0`, `/` as `~1`), with two departures: `/` is the whole
+arguments object (never a key `""`), and `?` stands for a data-named key. A
+`required` refusal appends the missing schema name to the parent's path. The
+format relates to a suggestion's `missingFields` as follows: a root path
+`/name` is the bare `missingFields` entry `name` (unescaped), and a nested
+entry is the same escaped pointer in both (for example `/vendor/a~1b~0c`).
+The bundled view shows a root issue without its leading `/`, so its refused
+fields read like the missing-information list. `ProposalValidationError`
+reasons share the schema-owned segment rule but stay unescaped.
+`keyword` is the failing schema keyword. Argument values, Ajv
+`params`/messages and handler messages are never included. A `validate`
+refusal has no `issues` (the handler contract returns only `ok`). The size and
+shape preconditions checked before the schema runs (arguments over the policy
+byte limit, or a handler schema that is not a closed `type: 'object'` with
+`additionalProperties: false`) stay a plain `Error`: they fail closed as a
+denial, never as the inline refusal. Apply-time and
 external-send revalidation and result-schema checks keep a plain `Error`. The component shows an inline message and
 keeps the view and draft when `preview` either rejects with an error whose
 `name` is `HandlerArgumentsInvalidError` or resolves `{ rejected: 'invalid' }`
-(`PreviewRejection`). A transport that crosses a process boundary preserves
-the inline UX by keeping that name (for example re-throwing an `Error` with
+(`PreviewRejection`, optionally with the same `issues`). A transport that
+crosses a process boundary preserves the inline UX by keeping that name and
+`issues` (for example re-throwing an `Error` with
 `name = 'HandlerArgumentsInvalidError'` in the browser callback) or by
-returning `{ rejected: 'invalid' }` for that case only, as the maintained
-fixture's `previewForReview` does. Without either, the refusal behaves like
+returning `{ rejected: 'invalid', issues? }` for that case only, as the
+maintained fixture's `previewForReview` and `startActionForReview` do. Since
+#4281 the fixture's rejection body also carries `issues` when the schema
+refused; read `rejected === 'invalid'` rather than comparing the whole body
+with strict equality. Without either, the refusal behaves like
 any other failure: the view is cleared exactly as before this change, and the
 reviewer's in-memory draft returns after an authorized refresh. Every other
 thrown preview or candidate-search failure (denied, revoked, unavailable or
@@ -346,8 +376,17 @@ needs the reviewer grant and keeps its handler fixed, so only its arguments can
 be corrected),
 runs the handler's normal `validate`/`preview`, publishes a `waiting_review`
 revision and requires the same explicit approval and apply as a generated
-proposal. Replays with the same request return the same review; changed arguments
-or reason conflict. Such actions are never automation-eligible: `authorizeAutomatic`
+proposal. The reviewer typed these arguments, so a handler argument-schema or
+`validate` refusal throws `HandlerArgumentsInvalidError` with the value-free
+`issues` described above, and the rolled-back transaction leaves no action row
+(#4281). Every other refusal (input shape, access, handler unavailable, item
+resolved, identity or request conflict, normalization mismatch) stays a plain
+denial. `startAction` follows the `preview` contract: it throws, or a transport
+may resolve `{ rejected: 'invalid', issues? }` for that one case. The component
+keeps the start form, handler, arguments and reason, shows an inline refusal and
+lists any field paths; any other failure clears the view as before. Replays
+with the same request return the same review; changed arguments or reason
+conflict. Such actions are never automation-eligible: `authorizeAutomatic`
 refuses them regardless of policy opt-ins. The UI pre-fills arguments only from a
 same-handler suggestion (for example a `needs_review` one) and a single original's
 evidence references, lists the required fields still missing, and submits exactly

package/agents/execution.md

@@ -84,8 +84,10 @@ refuses plan handlers and resolved items, binds the current analysis revision's
 completed/partial attempt, inserts an action keyed `reviewer:<requestId>` with
 `data.origin = 'reviewer-selected'`, and reuses `buildBinding`/`publish`: schema
 validation, `validate`, `preview`, exact normalized arguments, target locks,
-evidence pins and the request ledger behave exactly as for `previewProposal`.
-Replays re-preview against the original revision and return the same review.
+evidence pins and the request ledger behave exactly as for `previewProposal`,
+including the typed `HandlerArgumentsInvalidError` (with value-free `issues`)
+for an argument-schema or `validate` refusal of the reviewer's arguments;
+every other refusal stays a plain `Error` (#4281). Replays re-preview against the original revision and return the same review.
 Approval, apply, retention, redaction and reconciliation are unchanged.
 `authorizeAutomatic` refuses `reviewer-selected` actions and resolved items;
 human routing is never machine authority.

package/dist/argument-issues.d.ts

@@ -0,0 +1,29 @@
+import { type ErrorObject } from 'ajv';
+import type { HandlerArgumentIssue } from './review-dto.js';
+/**
+ * Keep only path segments the schema itself names: indexes into an actual
+ * array in the instance, and keys declared under `properties`. Anything else
+ * (keys under `additionalProperties`/`patternProperties`, numeric keys of an
+ * object, or an unknown key) is data and becomes `?`. `/` is the whole
+ * instance. With `escaped`, kept segments are RFC 6901-escaped (`~0`, `~1`);
+ * without it (the `ProposalValidationError` reason format) they are not.
+ */
+export declare function schemaOwnedPath(instancePath: string, schema: unknown, instance?: unknown, escaped?: boolean): string;
+/** Most field details one `HandlerArgumentsInvalidError` carries. */
+export declare const HANDLER_ARGUMENT_ISSUE_LIMIT = 20;
+/** Longest issue path; a deeper path keeps its prefix. */
+export declare const HANDLER_ARGUMENT_PATH_LIMIT = 160;
+/**
+ * Value-free field details for an argument-schema refusal: RFC 6901-escaped
+ * schema-owned paths (see `schemaOwnedPath`) and the failing schema keyword. A `required` failure
+ * names the schema-declared missing property; no other Ajv `params`, message,
+ * or instance value is ever read into the result. Bounded and frozen.
+ */
+export declare function handlerArgumentIssues(errors: readonly ErrorObject[] | null | undefined, schema: unknown, instance: unknown): readonly HandlerArgumentIssue[];
+/**
+ * Re-validate refused arguments with every error collected, only to describe
+ * the refusal. The authoritative accept/refuse decision is the caller's own
+ * validator; this never changes it.
+ */
+export declare function describeArgumentRefusal(schema: Record<string, unknown>, value: unknown): readonly HandlerArgumentIssue[];
+//# sourceMappingURL=argument-issues.d.ts.map

package/dist/argument-issues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"argument-issues.d.ts","sourceRoot":"","sources":["../src/argument-issues.ts"],"names":[],"mappings":"AAAA,OAAY,EAAE,KAAK,WAAW,EAAE,MAAM,KAAK,CAAC;AAC5C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAkB5D;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,OAAO,EACf,QAAQ,CAAC,EAAE,OAAO,EAClB,OAAO,UAAQ,GACd,MAAM,CAgDR;AAED,qEAAqE;AACrE,eAAO,MAAM,4BAA4B,KAAK,CAAC;AAC/C,0DAA0D;AAC1D,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAK/C;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,IAAI,GAAG,SAAS,EACjD,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,OAAO,GAChB,SAAS,oBAAoB,EAAE,CAgCjC;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,KAAK,EAAE,OAAO,GACb,SAAS,oBAAoB,EAAE,CAajC"}

package/dist/chunks/{execution-BzVQax0n.js → execution-Dv3G0d62.js}

@@ -51,9 +51,11 @@ var listReadGate = /* @__PURE__ */ Symbol("ingestion.listReadGate");
 //#endregion
 //#region src/proposal-errors.ts
 var HandlerArgumentsInvalidError = class extends Error {
-	constructor(message) {
+	issues;
+	constructor(message, issues) {
 		super(message);
 		this.name = "HandlerArgumentsInvalidError";
+		if (issues?.length) this.issues = issues;
 	}
 };
 var ProposalsNotConfiguredError = class extends Error {
@@ -6383,8 +6385,93 @@ var require_ajv = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	});
 }));
 //#endregion
-//#region src/feedback-internal.ts
+//#region src/argument-issues.ts
 var import_ajv = /* @__PURE__ */ __toESM(require_ajv(), 1);
+function schemaNodes(node) {
+	if (!node || typeof node !== "object" || Array.isArray(node)) return [];
+	const current = node;
+	return [current, ...[
+		"oneOf",
+		"anyOf",
+		"allOf"
+	].flatMap((keyword) => Array.isArray(current[keyword]) ? current[keyword].flatMap(schemaNodes) : [])];
+}
+function escapeSegment(segment) {
+	return segment.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function schemaOwnedPath(instancePath, schema, instance, escaped = false) {
+	if (!instancePath) return "/";
+	let nodes = schemaNodes(schema);
+	let value = instance;
+	const segments = instancePath.split("/").slice(1);
+	const kept = [];
+	for (const raw of segments) {
+		const segment = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+		if (/^\d+$/.test(segment) && Array.isArray(value)) {
+			kept.push(segment);
+			value = value[Number(segment)];
+			nodes = nodes.flatMap((node) => node.type === "array" || node.items !== void 0 ? schemaNodes(node.items) : []);
+			continue;
+		}
+		value = value && typeof value === "object" && !Array.isArray(value) ? value[segment] : void 0;
+		const owners = nodes.filter((node) => {
+			const properties = node.properties;
+			return !!properties && typeof properties === "object" && Object.hasOwn(properties, segment);
+		});
+		if (owners.length) {
+			kept.push(segment);
+			nodes = owners.flatMap((node) => schemaNodes(node.properties[segment]));
+		} else {
+			kept.push("?");
+			nodes = nodes.flatMap((node) => typeof node.additionalProperties === "object" ? schemaNodes(node.additionalProperties) : []);
+		}
+	}
+	return `/${kept.map((segment) => escaped && segment !== "?" ? escapeSegment(segment) : segment).join("/")}`;
+}
+var HANDLER_ARGUMENT_ISSUE_LIMIT = 20;
+var HANDLER_ARGUMENT_PATH_LIMIT = 160;
+var ERRORS_EXAMINED = 200;
+var KEYWORD = /^[A-Za-z$][A-Za-z0-9_$-]{0,63}$/;
+function handlerArgumentIssues(errors, schema, instance) {
+	const issues = [];
+	const seen = /* @__PURE__ */ new Set();
+	const paths = /* @__PURE__ */ new Map();
+	const all = errors ?? [];
+	for (let index = 0; index < all.length && index < ERRORS_EXAMINED && issues.length < 20; index++) {
+		const error = all[index];
+		let path = paths.get(error.instancePath);
+		if (path === void 0) {
+			path = schemaOwnedPath(error.instancePath, schema, instance, true);
+			paths.set(error.instancePath, path);
+		}
+		const missing = error.params.missingProperty;
+		if (error.keyword === "required" && typeof missing === "string") path = `${path === "/" ? "" : path}/${escapeSegment(missing)}`;
+		if (path.length > 160) path = path.slice(0, 160).replace(/~$/, "");
+		const keyword = KEYWORD.test(error.keyword) ? error.keyword : void 0;
+		const key = `${path}\0${keyword ?? ""}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		issues.push(Object.freeze(keyword ? {
+			path,
+			keyword
+		} : { path }));
+	}
+	return Object.freeze(issues);
+}
+function describeArgumentRefusal(schema, value) {
+	try {
+		const check = new import_ajv.default({
+			strict: true,
+			allErrors: true,
+			validateFormats: false
+		}).compile(schema);
+		return check(value) ? Object.freeze([]) : handlerArgumentIssues(check.errors, schema, value);
+	} catch {
+		return Object.freeze([]);
+	}
+}
+//#endregion
+//#region src/feedback-internal.ts
 var feedbackActionTransaction = /* @__PURE__ */ Symbol("ingestion.feedbackActionTransaction");
 var feedbackDiscoveryContext = /* @__PURE__ */ Symbol("ingestion.feedbackDiscoveryContext");
 //#endregion
@@ -6640,13 +6727,14 @@ var IntakeExecutionService = class IntakeExecutionService {
 	}
 	/**
 	* `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
+	* also carries corrections, reviewer-started actions and plan preview):
+	* only their schema refusal is the correctable
+	* `HandlerArgumentsInvalidError`, with value-free field `issues`. 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 arguments_ ? new HandlerArgumentsInvalidError("Invalid handler payload") : /* @__PURE__ */ new Error("Invalid handler payload");
+		if (!this.ajv.compile(schema)(value)) throw arguments_ ? new HandlerArgumentsInvalidError("Invalid handler payload", describeArgumentRefusal(schema, value)) : /* @__PURE__ */ new Error("Invalid handler payload");
 	}
 	/**
 	* The read-only half of `access`: current host authority, policy and
@@ -6969,7 +7057,7 @@ var IntakeExecutionService = class IntakeExecutionService {
 		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-D3UTF8fm.js").then((n) => n.r);
+		const { IntakeFeedbackService } = await import("./feedback-PLOZth0a.js").then((n) => n.r);
 		await new IntakeFeedbackService(this.options, this).assertActionLineage(String(bound.action.id), db, String(bound.proposal.id));
 	}
 	async getAction(actionId) {
@@ -7167,9 +7255,11 @@ var IntakeExecutionService = class IntakeExecutionService {
 		});
 	}
 	/**
-	* `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.
+	* `reviewed` marks arguments a reviewer is previewing, correcting or
+	* starting a chosen handler with: only then is an argument-schema or
+	* `validate` refusal the typed `HandlerArgumentsInvalidError`. Every other
+	* refusal here stays a plain denial; 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));
@@ -8119,7 +8209,7 @@ var IntakeExecutionService = class IntakeExecutionService {
 				handlerVersion: handler.version,
 				args: frozen.args
 			};
-			const binding = await this.buildBinding(db, item, preview);
+			const binding = await this.buildBinding(db, item, preview, true);
 			return this.publish(db, item, preview, binding);
 		});
 	}
@@ -8510,6 +8600,6 @@ async function continueIntakeReview(service, actionId, task) {
 	return service.applyAction(actionId);
 }
 //#endregion
-export { listReadGate as _, resolveIntakePolicy as a, require_ajv as c, GenerationSnapshotStaleError as d, GenerationSourceStaleError as f, generationSnapshotRead as g, discoveryTransaction as h, intakeBindingDigest as i, UNFINISHED_ACTION_STATES as l, ProposalsNotConfiguredError as m, IntakeExecutionService as n, feedbackActionTransaction as o, HandlerArgumentsInvalidError as p, continueIntakeReview as r, feedbackDiscoveryContext as s, IntakeAccessDeniedError as t, redactedCeiling as u, __exportAll as v, __toESM as y };
+export { __toESM as C, __exportAll as S, HandlerArgumentsInvalidError as _, resolveIntakePolicy as a, generationSnapshotRead as b, HANDLER_ARGUMENT_ISSUE_LIMIT as c, schemaOwnedPath as d, require_ajv as f, GenerationSourceStaleError as g, GenerationSnapshotStaleError as h, intakeBindingDigest as i, HANDLER_ARGUMENT_PATH_LIMIT as l, redactedCeiling as m, IntakeExecutionService as n, feedbackActionTransaction as o, UNFINISHED_ACTION_STATES as p, continueIntakeReview as r, feedbackDiscoveryContext as s, IntakeAccessDeniedError as t, describeArgumentRefusal as u, ProposalsNotConfiguredError as v, listReadGate as x, discoveryTransaction as y };
 
-//# sourceMappingURL=execution-BzVQax0n.js.map
+//# sourceMappingURL=execution-Dv3G0d62.js.map