@kontourai/survey 1.13.0 → 1.14.0

package/dist/src/current-proposed-review-item.d.ts

@@ -38,6 +38,12 @@ export interface CurrentProposedReviewItemInput {
         readonly current?: string;
         readonly proposed?: string;
     };
+    /**
+     * Whether the reviewer may edit the proposed value inline. Defaults to
+     * `true`. Pass `false` for keep/use/reject-only queues (see
+     * {@link ReviewItemSpec.editable}).
+     */
+    readonly editable?: boolean;
 }
 /**
  * Builds the two-candidate current/proposed {@link ReviewItem} envelope that

package/dist/src/current-proposed-review-item.js

@@ -38,6 +38,7 @@ export function currentProposedReviewItem(input) {
             ...(selectedCandidateId ? { selectedCandidateId } : {}),
             ...(input.rationale ? { rationale: input.rationale } : {}),
             ...(input.producerPolicy ? { producerPolicy: input.producerPolicy } : {}),
+            ...(input.editable === false ? { editable: false } : {}),
             projection: { ...input.projection, candidateSetId },
         },
         status: {

package/dist/src/review-resource.d.ts

@@ -142,6 +142,17 @@ export interface ReviewItemSpec {
      * Absent → a plain text editor with no validation (today's behavior).
      */
     valueDescriptor?: ReviewValueDescriptor;
+    /**
+     * Whether the reviewer may edit the proposed value inline before accepting
+     * it. Defaults to `true` (today's behavior). Set `false` for queues where an
+     * edited value is meaningless or must not be accepted — an approve/keep
+     * identity decision, a value the producer will re-derive, a review that only
+     * chooses between the two candidates as given. The workbench then renders no
+     * editor at all: the decision is keep-current / use-proposed / reject only,
+     * and `effectiveValue` is always the selected candidate's own value. This is
+     * enforcement (the affordance is absent), not a cosmetic hide.
+     */
+    editable?: boolean;
 }
 export interface ReviewItemStatus {
     observedCandidateCount?: number;

package/dist/src/review-workbench/review-queue-session.js

@@ -197,7 +197,15 @@ export function buildReviewSessionEvents(session, sessionName = defaultReviewSes
         const candidate = candidateForDecision(item, decision);
         const definition = workbenchDecisionDefinitions[decision];
         const reviewDecisionName = `${item.metadata.name}-${decision}`;
-        const data = { workbenchDecision: decision };
+        // Carry the reviewer's inline edit in the event itself (accept-proposed
+        // only — it is the sole decision where an edited value is meaningful), so
+        // that replaying snapshot + events reconstructs editedValuesByItemName and
+        // the server apply boundary derives effectiveValue from it. Without this
+        // the edit lives only in browser state and never survives replay.
+        const editedValue = decision === "accept-proposed" ? session.editedValuesByItemName?.[item.metadata.name] : undefined;
+        const data = editedValue !== undefined
+            ? { workbenchDecision: decision, workbenchEditedValue: editedValue }
+            : { workbenchDecision: decision };
         events.push(buildReviewSessionEvent(session, {
             sessionName,
             sequence: events.length + 1,
@@ -252,24 +260,49 @@ export function replayReviewSessionEvents(startState, events) {
         }
         if ((event.spec.eventType === "decision-changed" || event.spec.eventType === "decision-submitted")
             && event.spec.reviewItemName) {
+            const itemName = event.spec.reviewItemName;
             if (isClearedWorkbenchDecisionEvent(event)) {
-                const { [event.spec.reviewItemName]: _removed, ...remainingDecisions } = session.decisionsByItemName;
-                return { ...session, decisionsByItemName: remainingDecisions };
+                const { [itemName]: _removedDecision, ...remainingDecisions } = session.decisionsByItemName;
+                const { [itemName]: _removedEdit, ...remainingEdits } = session.editedValuesByItemName ?? {};
+                return { ...session, decisionsByItemName: remainingDecisions, editedValuesByItemName: remainingEdits };
             }
             const decision = workbenchDecisionFromEvent(event);
-            return decision
-                ? {
-                    ...session,
-                    decisionsByItemName: {
-                        ...session.decisionsByItemName,
-                        [event.spec.reviewItemName]: decision,
-                    },
-                }
-                : session;
+            if (!decision) {
+                return session;
+            }
+            // Restore the inline edit the event carried (accept-proposed only); any
+            // other decision, or an accept with no carried edit, clears a stale edit
+            // for this item so effectiveValue can't fall back to an edit the
+            // reviewer moved away from.
+            const editedValue = workbenchEditedValueFromEvent(event);
+            const editedValuesByItemName = { ...session.editedValuesByItemName };
+            if (decision === "accept-proposed" && editedValue !== undefined) {
+                editedValuesByItemName[itemName] = editedValue;
+            }
+            else {
+                delete editedValuesByItemName[itemName];
+            }
+            return {
+                ...session,
+                decisionsByItemName: {
+                    ...session.decisionsByItemName,
+                    [itemName]: decision,
+                },
+                editedValuesByItemName,
+            };
         }
         return session;
     }, startState);
 }
+/**
+ * Extracts a decision event's carried inline edit, or `undefined` when the
+ * event carries none. The edit rides `data.workbenchEditedValue`.
+ */
+function workbenchEditedValueFromEvent(event) {
+    return event.spec.data && "workbenchEditedValue" in event.spec.data
+        ? event.spec.data.workbenchEditedValue
+        : undefined;
+}
 /**
  * Detects the explicit "clear this ReviewItem's decision" replay signal (emitted
  * by the workbench's "Change" / undo control): a decision event whose

package/dist/src/review-workbench/review-workbench.js

@@ -567,7 +567,7 @@ function renderDiffRow(item, current, proposed, targetLabel, decided, effectiveP
       <div class="val proposed">
         <div class="vlbl">Proposed</div>
         <div class="vtext" data-value data-testid="proposed-value">${escapeHtml(effectiveProposedText)}</div>
-        ${decided ? "" : renderProposedValueEditor(item, proposed, targetLabel)}
+        ${decided || item.spec.editable === false ? "" : renderProposedValueEditor(item, proposed, targetLabel)}
       </div>
     </div>
   `;
@@ -968,6 +968,16 @@ function createReviewWorkbenchController(root, startState, options) {
         const candidate = item && decision ? candidateForDecision(item, decision) : undefined;
         const definition = decision ? workbenchDecisionDefinitions[decision] : undefined;
         const note = itemName ? session.notesByItemName[itemName] : undefined;
+        // Carry the reviewer's inline edit in the event (accept-proposed only), so
+        // it survives replay and the server apply boundary derives the edited
+        // effectiveValue from snapshot + events alone. setDecision updates the
+        // session before this runs, so the edit is already in state.
+        const editedValue = itemName && decision === "accept-proposed" ? session.editedValuesByItemName?.[itemName] : undefined;
+        const defaultData = decision
+            ? (editedValue !== undefined
+                ? { workbenchDecision: decision, workbenchEditedValue: editedValue }
+                : { workbenchDecision: decision })
+            : undefined;
         events = [
             ...events,
             buildReviewSessionEvent(session, {
@@ -980,7 +990,7 @@ function createReviewWorkbenchController(root, startState, options) {
                 candidateId: candidate?.id,
                 status: definition?.status,
                 rationale: note,
-                data: dataOverride ?? (decision ? { workbenchDecision: decision } : undefined),
+                data: dataOverride ?? defaultData,
             }),
         ];
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kontourai/survey",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "description": "Producer-side source, extraction, candidate, and review contracts for projecting verified claims into Surface.",
   "license": "Apache-2.0",
   "type": "module",