@startsimpli/ui 0.4.71 → 0.4.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/ui",
-  "version": "0.4.71",
+  "version": "0.4.73",
   "description": "Shared UI components package for StartSimpli applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -42,8 +42,8 @@
     "next": "^14.0.0 || ^15.0.0 || ^16.0.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
-    "@startsimpli/auth": "^0.4.31",
-    "@startsimpli/api": "^0.5.45"
+    "@startsimpli/api": "^0.5.45",
+    "@startsimpli/auth": "^0.4.31"
   },
   "peerDependenciesMeta": {
     "@startsimpli/api": {

package/src/components/collection/DraftReviewWorkspace.tsx

@@ -26,6 +26,8 @@ import {
   isChosen,
   gradeWords,
   wordTargets,
+  sourceOverlapCheck,
+  pickChanges,
   type DraftGroup,
   type DraftSource,
   type CheckStatus,
@@ -92,14 +94,7 @@ export function DraftReviewWorkspace({ client }: DraftReviewWorkspaceProps) {
   async function pick(group: DraftGroup, cand: EntityRecord) {
     setBusyKey(group.key);
     try {
-      await Promise.all(
-        group.candidates.map((c) =>
-          writeEntity(c, {
-            chosen: String(c.id) === String(cand.id),
-            status: String(c.id) === String(cand.id) ? 'selected' : field(c, 'status') === 'ready' ? 'ready' : '',
-          }),
-        ),
-      );
+      await Promise.all(group.candidates.map((c) => writeEntity(c, pickChanges(c.id, cand.id))));
       await qc.invalidateQueries({ queryKey: ['entities', 'draft'] });
     } catch (err) {
       notify.error(err instanceof Error ? err.message : 'Could not save the pick.');
@@ -108,10 +103,16 @@ export function DraftReviewWorkspace({ client }: DraftReviewWorkspaceProps) {
     }
   }
 
-  async function markReady(record: EntityRecord) {
+  async function markReady(record: EntityRecord, reason?: string) {
     setBusyKey(String(record.id));
     try {
-      await writeEntity(record, { status: 'ready', chosen: true });
+      await writeEntity(record, {
+        status: 'ready',
+        chosen: true,
+        // A source-overlap fail doesn't hard-block the accept — the reviewer can
+        // override with a reason (768w.18.16.2). Record it so the override is auditable.
+        ...(reason ? { ready_override_reason: reason } : {}),
+      });
       await qc.invalidateQueries({ queryKey: ['entities', 'draft'] });
     } catch (err) {
       notify.error(err instanceof Error ? err.message : 'Could not mark ready.');
@@ -185,7 +186,7 @@ function StoryGroup({
   openId: string | null;
   onToggleOpen: (id: string) => void;
   onPick: (g: DraftGroup, c: EntityRecord) => Promise<void>;
-  onMarkReady: (c: EntityRecord) => Promise<void>;
+  onMarkReady: (c: EntityRecord, reason?: string) => Promise<void>;
   busy: boolean;
   busyId: string | null;
 }) {
@@ -228,7 +229,7 @@ function StoryGroup({
             key={`rev-${c.id}`}
             record={c}
             contentType={group.contentType}
-            onMarkReady={() => onMarkReady(c)}
+            onMarkReady={(reason) => onMarkReady(c, reason)}
             marking={busyId === String(c.id)}
           />
         ))}
@@ -303,7 +304,7 @@ function ContentReview({
 }: {
   record: EntityRecord;
   contentType: string;
-  onMarkReady: () => void;
+  onMarkReady: (reason?: string) => void;
   marking: boolean;
 }) {
   const blog = field(record, 'blog');
@@ -313,6 +314,14 @@ function ContentReview({
   const checks = obj(readData(record.data, 'auto_checks'));
   const ready = field(record, 'status') === 'ready';
 
+  // Verbatim-overlap guardrail (768w.18.16.2): recompute the source-overlap check
+  // client-side against the cited article text on the record. Only surfaces when
+  // the draft actually carries source_texts. A fail gates the accept below.
+  const overlap = sourceOverlapCheck(record);
+  const overlapFail = overlap?.status === 'fail';
+  const [override, setOverride] = useState('');
+  const blocked = overlapFail && !ready && override.trim().length < 4;
+
   const tags = ((): string[] => {
     const t = seo.tags;
     if (Array.isArray(t)) return t.map(String);
@@ -431,16 +440,55 @@ function ContentReview({
                   sources {approvedSources ? 'approved' : 'unverified'}
                 </Badge>
               )}
+              {overlap && (
+                <Badge
+                  variant="outline"
+                  title={overlap.detail}
+                  className={`text-[10px] ${
+                    overlap.status === 'pass'
+                      ? 'text-emerald-700'
+                      : overlap.status === 'warn'
+                        ? 'text-amber-700'
+                        : 'text-rose-700'
+                  }`}
+                >
+                  {overlap.status === 'pass' ? 'original wording' : `source overlap: ${overlap.detail}`}
+                </Badge>
+              )}
             </div>
           </section>
 
-          <Button onClick={onMarkReady} disabled={marking || ready} className="w-full">
+          {overlapFail && !ready && (
+            <section>
+              <div className="rounded-md border border-rose-200 bg-rose-50 p-3 text-xs text-rose-800">
+                <p className="flex items-center gap-1 font-medium">
+                  <AlertTriangle className="h-3.5 w-3.5" /> This draft copies too much from its source ({overlap?.detail}).
+                </p>
+                <p className="mt-1 text-rose-700">Paraphrase the flagged run, or give a reason to publish it anyway.</p>
+                <textarea
+                  value={override}
+                  onChange={(e) => setOverride(e.target.value)}
+                  placeholder="Reason to publish despite the overlap…"
+                  className="mt-2 w-full rounded border border-rose-200 bg-white p-2 text-xs text-gray-800"
+                  rows={2}
+                />
+              </div>
+            </section>
+          )}
+
+          <Button
+            onClick={() => onMarkReady(overlapFail ? override.trim() : undefined)}
+            disabled={marking || ready || blocked}
+            className="w-full"
+          >
             {ready ? (
               <>
                 <CheckCircle2 className="mr-1.5 h-4 w-4" /> Ready to post
               </>
             ) : marking ? (
               'Saving…'
+            ) : overlapFail ? (
+              'Mark ready to post anyway'
             ) : (
               'Mark ready to post'
             )}

package/src/components/collection/__tests__/drafts.test.ts

@@ -1,4 +1,4 @@
-import { parseSources, normUrl, groupKeyOf, groupDrafts, candidateTitle, gradeWords, wordTargets } from '../drafts';
+import { parseSources, normUrl, groupKeyOf, groupDrafts, candidateTitle, gradeWords, wordTargets, sourceOverlapCheck, pickChanges } from '../drafts';
 import type { EntityRecord } from '../types';
 
 function rec(id: string, name: string, data: Record<string, unknown>): EntityRecord {
@@ -89,3 +89,48 @@ describe('gradeWords', () => {
     expect(gradeWords(100, wordTargets('lead_magnet').linkedin)).toBe('none');
   });
 });
+
+describe('sourceOverlapCheck (768w.18.16.2 wiring)', () => {
+  const SOURCE =
+    'A Houthi threat to impose a naval blockade against Saudi Arabia in the Red Sea could significantly ' +
+    'widen the Iran war and strain a U.S. military already focused on stopping attacks across the region.';
+
+  it('returns null when the draft carries no source_texts', () => {
+    expect(sourceOverlapCheck(rec('d1', 'Draft', { blog: SOURCE }))).toBeNull();
+    expect(sourceOverlapCheck(rec('d2', 'Draft', { blog: SOURCE, source_texts: [] }))).toBeNull();
+  });
+
+  it('FAILS when the blog copies a long verbatim run from a source_text', () => {
+    const check = sourceOverlapCheck(rec('d3', 'Draft', { blog: `Intro. ${SOURCE} Outro.`, source_texts: [SOURCE] }));
+    expect(check).not.toBeNull();
+    expect(check!.id).toBe('source-overlap');
+    expect(check!.status).toBe('fail');
+  });
+
+  it('PASSES when the blog is original prose against the source_text', () => {
+    const original =
+      'Foreign operators with Gulf shipping exposure should reassess route reliability, war-risk premiums, ' +
+      'and contract terms as regional tensions evolve this quarter.';
+    const check = sourceOverlapCheck(rec('d4', 'Draft', { blog: original, source_texts: [SOURCE] }));
+    expect(check).not.toBeNull();
+    expect(check!.status).toBe('pass');
+  });
+
+  it('reads camelCased sourceTexts too', () => {
+    const check = sourceOverlapCheck(rec('d5', 'Draft', { blog: `x ${SOURCE}`, sourceTexts: [SOURCE] }));
+    expect(check!.status).toBe('fail');
+  });
+});
+
+describe('pickChanges (startsim-yvd3 — pick must not write an invalid status)', () => {
+  it('marks the picked candidate chosen and writes NO status key', () => {
+    const picked = pickChanges('a', 'a');
+    expect(picked).toEqual({ chosen: true });
+    expect('status' in picked).toBe(false); // status enum is the tenant's; picking must not touch it
+    expect(pickChanges('b', 'a')).toEqual({ chosen: false });
+  });
+  it('compares ids as strings (handles number vs string ids)', () => {
+    expect(pickChanges(7 as unknown as string, '7')).toEqual({ chosen: true });
+    expect(pickChanges(7 as unknown as string, 8 as unknown as string)).toEqual({ chosen: false });
+  });
+});

package/src/components/collection/drafts.ts

@@ -9,6 +9,7 @@
  */
 import type { EntityRecord } from './types';
 import { readData } from './data';
+import { runContentChecks, type ContentCheck } from '../validation';
 
 export interface DraftSource {
   url: string;
@@ -158,3 +159,31 @@ export function gradeWords(count: number, [lo, hi]: [number, number]): CheckStat
   if (count > hi) return 'high';
   return 'ok';
 }
+
+/**
+ * The record change a Pick applies to ONE candidate: mark it chosen (true for the
+ * picked candidate, false for the rest). Picking is a selection flag — it must NOT
+ * write a lifecycle `status`. The tenant constrains draft `status` to an enum, so
+ * writing 'selected' (or '') 400s the whole pick (startsim-yvd3); the "picked"
+ * badge already keys off `chosen` via isChosen(). Pure, so it's unit-tested.
+ */
+export function pickChanges(candidateId: EntityRecord['id'], pickedId: EntityRecord['id']): { chosen: boolean } {
+  return { chosen: String(candidateId) === String(pickedId) };
+}
+
+/**
+ * The verbatim-overlap guardrail (768w.18.16.2) for a single draft. Runs the
+ * shared `source-overlap` check over the draft's blog + linkedin against the
+ * cited source article TEXT stamped on the record (`data.source_texts`, populated
+ * by the writer's Stamp Source Texts step). Returns null when the draft carries
+ * no source text — there is no ground truth to compare against, so there is
+ * nothing to surface. Pure, so the wiring is unit-testable without React.
+ */
+export function sourceOverlapCheck(r: EntityRecord): ContentCheck | null {
+  const raw = readData(r.data, 'source_texts');
+  const sourceTexts = Array.isArray(raw) ? raw.map(str).filter(Boolean) : [];
+  if (sourceTexts.length === 0) return null;
+  const blog = str(readData(r.data, 'blog'));
+  const linkedin = str(readData(r.data, 'linkedin'));
+  return runContentChecks({ blog, linkedin }, { sourceTexts }).find((c) => c.id === 'source-overlap') ?? null;
+}