@anthusai/papyrus 5.43.0-next.40 → 5.43.0-next.42

package/amplify/functions/category-action/handler.ts

@@ -24,6 +24,7 @@ import {
   requestDelegation,
   type DelegationStore,
 } from "../shared/curation-delegation-flow";
+import { rejectionReasonCodeForWrittenReason } from "../../../lib/reference-policy";
 import { claimGroups } from "../../../lib/staff-groups";
 
 type ReviewHandler = Schema["reviewSteeringProposal"]["functionHandler"];
@@ -214,7 +215,15 @@ async function reviewReferenceCuration(
   const referenceId = normalizeRequiredString(event.arguments.referenceId, "referenceId");
   const action = normalizeReferenceCurationAction(event.arguments.action);
   const nextStatus = referenceCurationStatusForAction(action);
-  const reasonCode = normalizeReferenceRejectionReasonCode(event.arguments.reasonCode, action === "reject");
+  const writtenReason = normalizeOptionalString(event.arguments.note);
+  // A rejection needs a reason, and the editor's own sentence is one: with no reason code sent, the
+  // words are read for the code they name, so the scope-training negatives keep arriving from the
+  // surfaces that ask for words instead of a chip. Words that name no code are filed under "other".
+  const reasonCode = normalizeReferenceRejectionReasonCode(event.arguments.reasonCode)
+    ?? (action === "reject" ? rejectionReasonCodeForWrittenReason(writtenReason) : null);
+  if (action === "reject" && !reasonCode) {
+    throw new Error("A rejection needs a reason: say why in your own words, or send a reasonCode.");
+  }
   const reference = await getRequiredRecord(client.models.Reference, referenceId, "Reference");
   const requestedSectionId = normalizeOptionalString(event.arguments.sectionId);
   const sectionRecord = requestedSectionId
@@ -225,7 +234,7 @@ async function reviewReferenceCuration(
   const actorSub = normalizeOptionalString(event.arguments.actorSub) ?? getIdentitySub(event);
   const actorLabel = normalizeOptionalString(event.arguments.actorLabel) ?? getIdentityLabel(event);
   const actor = actorLabel ?? actorSub ?? "Papyrus newsroom";
-  const note = normalizeOptionalString(event.arguments.note);
+  const note = writtenReason;
   const referenceLineageId = normalizeOptionalString(reference.lineageId) ?? referenceId;
   const referenceVersionNumber = typeof reference.versionNumber === "number" ? reference.versionNumber : null;
   const referenceTitle = normalizeOptionalString(reference.title) ?? normalizeOptionalString(reference.externalItemId) ?? referenceId;
@@ -2095,12 +2104,10 @@ const REFERENCE_REJECTION_REASON_CODES = new Set([
   "other",
 ]);
 
-function normalizeReferenceRejectionReasonCode(value: unknown, required: boolean): string | null {
+/** A supplied reason code, validated. Whether a rejection has a reason at all is the caller's rule. */
+function normalizeReferenceRejectionReasonCode(value: unknown): string | null {
   const normalized = normalizePolicyToken(value);
-  if (!normalized) {
-    if (required) throw new Error("reasonCode is required when rejecting a reference.");
-    return null;
-  }
+  if (!normalized) return null;
   if (!REFERENCE_REJECTION_REASON_CODES.has(normalized)) {
     throw new Error(`Unsupported reference rejection reason code ${normalized}.`);
   }

package/components/decision-control.tsx

@@ -4,6 +4,7 @@ import { useEffect, useId, useState } from "react";
 import { CheckIcon, Loader2Icon, XIcon } from "lucide-react";
 import { UNRECORDED_CONFIDENCE } from "../lib/reference-feed-ranking";
 import { cn } from "../lib/utils";
+import { AutoGrowTextarea } from "./ui/auto-grow-textarea";
 import type { CardPrediction, ReviewChoice } from "./reference-review-card";
 
 /**
@@ -236,7 +237,7 @@ export function DecisionControl({
           </label>
           {/* Written reasons only. A row of canned answers collects a label the model mostly has already;
               what trains the next prediction is a sentence. */}
-          <textarea
+          <AutoGrowTextarea
             className={cn(
               "w-full rounded-[var(--feed-radius-md,16px)] border-0 bg-[var(--feed-control)] px-3 py-2 text-sm leading-5 text-foreground outline-none transition-[min-height] placeholder:text-muted-foreground focus-visible:ring-[3px] focus-visible:ring-ring",
               field,
@@ -245,7 +246,7 @@ export function DecisionControl({
             id={fieldId}
             onBlur={() => { if (!disabled) onReasonCommit?.(); }}
             onChange={(event) => { setReasonDirty(true); onReasonChange?.(event.target.value); }}
-            placeholder="Why? In your own words — this is what the next prediction learns from."
+            placeholder="Why? In your own words…"
             value={reason}
           />
         </div>

package/components/use-reference-ratings.ts

@@ -38,8 +38,8 @@ export type RatingController = {
  * shows in both at once. `saved(id)` is the saved human answer; `seed(id)` the saved note and reason code.
  *   vote, then reason  -> the reason is saved onto the existing decision (on blur, or after a short pause)
  *   reason, then vote  -> the vote carries the reason
- * A Reject needs a reason code (the backend refuses one without), so it waits as `pending` until one is chosen; a typed reason is
- * kept in the store until it is saved and is never dropped by a failed save.
+ * A Reject needs a reason (the backend refuses one without): words or a reason code, whichever the surface asks for. With neither it
+ * waits as `pending` until one arrives; a typed reason is kept in the store until it is saved and is never dropped by a failed save.
  */
 export function useRatingStore({ save, saved, seed, needsReason, sticky, saveNote }: {
   save: RatingSave;
@@ -110,13 +110,17 @@ export function useRatingStore({ save, saved, seed, needsReason, sticky, saveNot
 
   const commit = useCallback(async (id: string, choice: ReviewChoice) => {
     if (finalDecision(id)) { void saveNoteOnly(id); return; }
-    const { note, reasonCode: chosenCode } = values(id);
-    // A typed reason is a reason: a Reject with words but no reason button is filed under "other" rather than left waiting.
-    const reasonCode = chosenCode ?? (choice === "reject" && note.trim() ? "other" : null);
-    if (choice === "reject" && !reasonCode && (latest.current.needsReason?.(id) ?? true)) { patch(id, { pending: "reject", askReason: true }); return; }
+    const { note, reasonCode } = values(id);
+    // A typed reason is a reason, so a Reject with words goes at once rather than waiting. It carries no
+    // code the editor did not pick: the backend reads the words for the code they name, and files words
+    // that name none under "other". Only a Reject with neither words nor a code waits for one.
+    if (choice === "reject" && !reasonCode && !note.trim() && (latest.current.needsReason?.(id) ?? true)) { patch(id, { pending: "reject", askReason: true }); return; }
     if (inFlight.current.has(id)) { dirty.current.add(id); return; }
     inFlight.current.add(id);
     dirty.current.delete(id);
+    // The note goes out with this save, so its own pending autosave has nothing left to send.
+    dirty.current.delete(`note:${id}`);
+    clearTimeout(timers.current[id]);
     const started = itemsRef.current[id] ?? EMPTY;
     patch(id, { pending: choice, askReason: false, feedback: { phase: "saving" } });
     try {

package/lib/reference-policy.ts

@@ -22,6 +22,84 @@ export function isScopeTrainingNegativeReason(code: string): boolean {
   return SCOPE_TRAINING_NEGATIVE_REASON_CODE_SET.has(code);
 }
 
+/**
+ * The phrases an editor writes when they mean one reason code and little else.
+ *
+ * The order matters, and the two scope-training codes come LAST: a sentence
+ * that also names a mechanical reason ("already have it, and off our beat") is
+ * filed under that reason instead. A false scope negative teaches the relevance
+ * classifier something wrong; a missed one only leaves it untaught.
+ *
+ * Each phrase is a whole word or wording, never a fragment, so "slopes" is not
+ * read as "slop". Words that say none of this yield no code at all rather than
+ * the nearest guess.
+ */
+const WRITTEN_REASON_PHRASES: ReadonlyArray<readonly [ReferenceRejectionReasonCode, readonly string[]]> = [
+  ["duplicate", [
+    "duplicate", "duplicates", "duplicated", "duplication", "dupe", "reprint", "reprinted",
+    "already have (it|this|that|the)", "already (got|covered|accepted|registered|ingested|indexed)",
+    "already in (our|the) (corpus|list|feed|knowledge base|library)", "same (source|piece|story) as",
+  ]],
+  ["unavailable", [
+    "paywall", "paywalled", "unavailable", "not available", "no longer (available|online|up|there|reachable)",
+    "behind a (paywall|login|subscription|sign in)", "(dead|broken|404) link", "link is (dead|broken)",
+    "(cannot|cant) (open|read|reach|access|download|retrieve)", "requires a (subscription|login|account|sign in)",
+    "taken down", "timed out", "page is gone",
+  ]],
+  ["provenance", [
+    "provenance", "unattributed", "unverified", "unverifiable", "untraceable",
+    "(cannot|cant) (verify|attribute)", "no (byline|author|citation|attribution|provenance)",
+    "(unknown|unclear|anonymous|missing) (author|source|origin|provenance)", "who wrote it",
+  ]],
+  ["low_quality", [
+    "(low|poor) quality", "poorly (written|sourced|argued|researched|edited)", "badly written", "sloppy",
+    "content farm", "clickbait", "seo (spam|bait|filler)", "slop", "junk", "spam", "no substance", "churnalism",
+  ]],
+  ["policy_exclusion", [
+    "policy exclusion", "(our|house|editorial) policy", "against (our )?policy",
+    "(policy|policies) (excludes?|forbids?|bars?|rules? out|says?)",
+    "(excluded|barred|ruled out|forbidden) by (our )?policy",
+    "we (dont|do not) (cover|run|publish|cite|take)", "not allowed", "disallowed", "prohibited",
+    "blocklist", "blocklisted", "blocked source",
+  ]],
+  ["out_of_scope", [
+    "out of scope", "outside (our|the) (scope|remit|coverage|beat|lane)", "not (in|within) (our|the) scope",
+    "off topic", "nothing to do with", "not (our|the) (beat|subject|topic|area|coverage)",
+    "not relevant", "no longer relevant", "irrelevant", "unrelated", "wrong (beat|subject|topic)",
+  ]],
+];
+
+const WRITTEN_REASON_PATTERNS: ReadonlyArray<readonly [ReferenceRejectionReasonCode, RegExp]> =
+  WRITTEN_REASON_PHRASES.map(([code, phrases]) => [code, new RegExp(`\\b(?:${phrases.join("|")})\\b`)] as const);
+
+/**
+ * The reason code a rejection is filed under when the editor gave none: what
+ * their own words plainly say, else "other".
+ *
+ * Words are a reason — a written sentence is what the editor actually gives
+ * now that there are no reason chips — but "other" is the honest answer for
+ * words that name no policy code, rather than a guess the sentence cannot
+ * support. Blank words are no reason at all, so this yields null and the
+ * caller refuses the rejection.
+ */
+export function rejectionReasonCodeForWrittenReason(writtenReason: unknown): ReferenceRejectionReasonCode | null {
+  const words = normalizeWrittenReason(writtenReason);
+  if (!words) return null;
+  for (const [code, pattern] of WRITTEN_REASON_PATTERNS) {
+    if (pattern.test(words)) return code;
+  }
+  return "other";
+}
+
+/** Lower case, apostrophes dropped ("don't" -> "dont") and every other gap a single space, so phrases match plain prose. */
+function normalizeWrittenReason(value: unknown): string {
+  return String(value ?? "")
+    .toLowerCase()
+    .replace(/['\u2018\u2019]/g, "")
+    .replace(/[^a-z0-9]+/g, " ")
+    .trim();
+}
+
 export function normalizeReferenceCurationStatus(value: unknown, defaultStatus: ReferenceCurationStatus = "pending"): ReferenceCurationStatus {
   const normalized = normalizePolicyToken(value ?? defaultStatus);
   if (normalized === "accepted" || normalized === "accept" || normalized === "ready" || normalized === "trusted") return "accepted";

package/lib/relevance-decisions.ts

@@ -149,11 +149,15 @@ export function currentRelevanceDecisions(relations: SemanticRelationRecord[]):
  * any other label, or a review without a label, rejects with the reason code,
  * which the existing scope-training rule turns back into a cyclotron label
  * (out_of_scope and policy_exclusion) or none.
+ *
+ * A rejection must say why, but either way of saying it will do: a reason code,
+ * or the editor's own words, which the curation Lambda reads for the code they
+ * name. Only a rejection with neither is refused.
  */
 export function curationForRelevanceReview(decision: RelevanceDecisionView, review: RelevanceReview): RelevanceCuration {
   const accepted = review.label !== null && review.label === decision.positiveLabel;
-  if (!accepted && !review.reasonCode) {
-    throw new Error("A review that does not accept the reference needs a reason code.");
+  if (!accepted && !review.reasonCode && !review.explanation?.trim()) {
+    throw new Error("A review that does not accept the reference needs a reason code, or a written reason.");
   }
   return {
     action: accepted ? "accept" : "reject",

package/package.json

@@ -510,7 +510,7 @@
       "optional": true
     }
   },
-  "version": "5.43.0-next.40",
+  "version": "5.43.0-next.42",
   "dependencies": {
     "@aws-amplify/adapter-nextjs": "^1.7.3",
     "@aws-crypto/sha256-js": "5.2.0",

package/routes.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "5.43.0-next.40",
+  "version": "5.43.0-next.42",
   "routes": [
     {
       "file": "app/%5F_preview/[[...path]]/route.ts",