mandrel 2.1.0 → 2.2.0

package/.agents/scripts/lib/orchestration/plan-text-hygiene.js

@@ -0,0 +1,230 @@
+/**
+ * plan-text-hygiene.js — deterministic text-hygiene lints over draft Story
+ * bodies (Story #4599).
+ *
+ * The text analysis of Stories #4592–#4594 (and domio#1684) surfaced three
+ * body-defect classes no gate checks: dangling prose citations whose carrier
+ * document is unlocatable, operator-directed open questions persisted into
+ * tickets executed by non-interactive sub-agents, and `## Slicing` sections
+ * carrying more mass than the `## Spec` they are supposed to checkpoint.
+ * This module makes those classes checkable at the one point a re-author
+ * loop exists — the pre-persist critic gate (`plan-critics.js`).
+ *
+ * Advisory by contract: findings are deterministic text for the workflow's
+ * re-author round. They never gate persist, never flip a dispatch verdict,
+ * and spawn nothing.
+ *
+ * Heuristics are deliberately narrow (few false positives over recall):
+ *
+ *   - **dangling-citation** — a sentence referencing a document section
+ *     (`§`, "design note", "review doc") with no repo-relative path and no
+ *     `#<digits>` issue anchor in the same sentence.
+ *   - **open-question** — interrogative-to-operator phrasing ("Flag if",
+ *     "TBD", "confirm with the operator", a trailing `?`) in Goal/Spec
+ *     prose outside code spans. Bodies record decisions; unresolved
+ *     unknowns belong in declarative Key Assumptions.
+ *   - **slicing-mass** — `## Slicing` character mass exceeding `## Spec`
+ *     character mass when both are present: checkpoints carrying
+ *     Spec-grade detail the Spec then re-covers.
+ *
+ * Pure, synchronous, no I/O. Operates on the draft `stories.json` array,
+ * reusing `parse()` from `lib/story-body/story-body.js` for section access.
+ * An unparseable draft body is skipped, not failed — hygiene is advisory
+ * and the persist validators own structural rejection.
+ *
+ * @module lib/orchestration/plan-text-hygiene
+ */
+
+import { parse } from '../story-body/story-body.js';
+
+/** Truncation length for the `evidence` excerpt on each finding. */
+const EVIDENCE_MAX_CHARS = 160;
+
+/**
+ * Phrases the citation heuristic treats as a reference to an external
+ * carrier document. Matched case-insensitively within one sentence.
+ */
+const CITATION_MARKERS = [/§/, /\bdesign note\b/i, /\breview doc\b/i];
+
+/**
+ * Anchors that locate a citation: a `#<digits>` issue reference or a
+ * repo-relative path (a slash-joined token carrying a file-ish segment).
+ */
+const ISSUE_ANCHOR = /#\d+/;
+const REPO_PATH_ANCHOR = /[\w.-]+\/[\w./-]+/;
+
+/**
+ * Operator-directed open-question phrasings. Each match is an instruction
+ * or question aimed at a human, which a non-interactive delivery sub-agent
+ * can never answer.
+ */
+const OPEN_QUESTION_MARKERS = [
+  /\bflag if\b/i,
+  /\bTBD\b/,
+  /\bconfirm with the operator\b/i,
+];
+
+/**
+ * @typedef {Object} TextHygieneFinding
+ * @property {'dangling-citation'|'open-question'|'slicing-mass'} kind
+ * @property {string} slug - The draft Story's slug ('' when absent).
+ * @property {string} evidence - Excerpt of the offending text.
+ * @property {string} message - Human-readable, re-author-actionable text.
+ */
+
+/**
+ * Strip fenced code blocks and inline code spans so code content (shell
+ * snippets, grep patterns, JSON) never trips a prose heuristic.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function stripCodeSpans(text) {
+  return text.replace(/```[\s\S]*?```/g, ' ').replace(/`[^`\n]*`/g, ' ');
+}
+
+/**
+ * Split prose into sentence-ish units. Newlines are boundaries too, so a
+ * bullet list yields one unit per bullet.
+ *
+ * @param {string} text
+ * @returns {string[]}
+ */
+function splitSentences(text) {
+  return text
+    .split(/(?<=[.!?])\s+|\n+/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Truncate an excerpt for the finding's `evidence` field.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function excerpt(text) {
+  const flat = text.replace(/\s+/g, ' ').trim();
+  return flat.length > EVIDENCE_MAX_CHARS
+    ? `${flat.slice(0, EVIDENCE_MAX_CHARS - 1)}…`
+    : flat;
+}
+
+/**
+ * dangling-citation: a citation-marker sentence with no locating anchor.
+ *
+ * @param {string} prose - Code-stripped body prose.
+ * @param {string} slug
+ * @returns {TextHygieneFinding[]}
+ */
+function findDanglingCitations(prose, slug) {
+  const findings = [];
+  for (const sentence of splitSentences(prose)) {
+    const cites = CITATION_MARKERS.some((m) => m.test(sentence));
+    if (!cites) continue;
+    const anchored =
+      ISSUE_ANCHOR.test(sentence) || REPO_PATH_ANCHOR.test(sentence);
+    if (anchored) continue;
+    findings.push({
+      kind: 'dangling-citation',
+      slug,
+      evidence: excerpt(sentence),
+      message:
+        'Citation names a document section but no repo-relative path or ' +
+        '#<issue> anchor locates it in the same sentence — the executing ' +
+        'agent cannot follow it. Anchor the citation or inline the claim.',
+    });
+  }
+  return findings;
+}
+
+/**
+ * open-question: operator-directed phrasing (or a trailing `?`) in prose a
+ * non-interactive sub-agent executes.
+ *
+ * @param {string} prose - Code-stripped Goal/Spec prose.
+ * @param {string} slug
+ * @returns {TextHygieneFinding[]}
+ */
+function findOpenQuestions(prose, slug) {
+  const findings = [];
+  for (const sentence of splitSentences(prose)) {
+    const marked =
+      OPEN_QUESTION_MARKERS.some((m) => m.test(sentence)) ||
+      sentence.endsWith('?');
+    if (!marked) continue;
+    findings.push({
+      kind: 'open-question',
+      slug,
+      evidence: excerpt(sentence),
+      message:
+        'Body text carries an operator-directed open question; the Story ' +
+        'is executed by a non-interactive sub-agent that cannot answer it. ' +
+        'Record the decision, or restate the unknown as a declarative Key ' +
+        'Assumption.',
+    });
+  }
+  return findings;
+}
+
+/**
+ * slicing-mass: `## Slicing` outweighing `## Spec` when both are present.
+ *
+ * @param {{ slicing?: string, spec?: string }} body - Parsed Story body.
+ * @param {string} slug
+ * @returns {TextHygieneFinding[]}
+ */
+function findSlicingMass(body, slug) {
+  const slicing = typeof body.slicing === 'string' ? body.slicing : '';
+  const spec = typeof body.spec === 'string' ? body.spec : '';
+  if (slicing.length === 0 || spec.length === 0) return [];
+  if (slicing.length <= spec.length) return [];
+  return [
+    {
+      kind: 'slicing-mass',
+      slug,
+      evidence: excerpt(slicing),
+      message:
+        `## Slicing (${slicing.length} chars) outweighs ## Spec ` +
+        `(${spec.length} chars) — checkpoints are carrying Spec-grade ` +
+        'detail. Keep each Slicing checkpoint to one line and move the ' +
+        'detail into ## Spec.',
+    },
+  ];
+}
+
+/**
+ * Evaluate the three text-hygiene lints over a draft Story array.
+ *
+ * @param {{ draftStories?: Array<object>|null }} args - The draft
+ *   `stories.json` array (raw Story objects with top-level `slug` /
+ *   `body`). Null/absent evaluates to zero findings (the single-delivery
+ *   shape authors no draft tickets).
+ * @returns {{ findings: TextHygieneFinding[] }}
+ */
+export function evaluateTextHygiene({ draftStories = null } = {}) {
+  const stories = Array.isArray(draftStories) ? draftStories : [];
+  const findings = [];
+  for (const story of stories) {
+    const slug = typeof story?.slug === 'string' ? story.slug : '';
+    let body;
+    try {
+      body = parse(story?.body).body;
+    } catch {
+      // Advisory lint: an unparseable body is the persist validators'
+      // rejection to make, not this evaluator's.
+      continue;
+    }
+    const goal = typeof body.goal === 'string' ? body.goal : '';
+    const spec = typeof body.spec === 'string' ? body.spec : '';
+    const bodyProse = stripCodeSpans(
+      typeof story.body === 'string' ? story.body : [goal, spec].join('\n'),
+    );
+    findings.push(
+      ...findDanglingCitations(bodyProse, slug),
+      ...findOpenQuestions(stripCodeSpans([goal, spec].join('\n')), slug),
+      ...findSlicingMass(body, slug),
+    );
+  }
+  return { findings };
+}

package/.agents/scripts/lib/orchestration/planning/decomposer-context.js

@@ -13,11 +13,10 @@ import { renderDecomposerSystemPrompt } from '../../templates/decomposer-prompts
 
 export function buildDecomposerSystemPrompt(
   heuristics = [],
-  { maxTickets, epicId } = {},
+  { maxTickets } = {},
 ) {
   const base = renderDecomposerSystemPrompt({
     maxTickets,
-    epicId,
   });
   const heuristicsStr =
     heuristics.length > 0

package/.agents/scripts/lib/orchestration/single-story-close/phases/code-review.js

@@ -28,7 +28,7 @@
  */
 
 import { parsePrNumberFromUrl } from '../../../github-url.js';
-import { runStoryReviewCore } from '../../story-close/phases/code-review.js';
+import { runStoryReviewCore } from '../../story-close/phases/review-core.js';
 import { postStructuredComment } from '../../ticketing/state.js';
 
 /**

package/.agents/scripts/lib/orchestration/story-close/phases/code-review.js

@@ -28,248 +28,111 @@
  * critical-halt path so the Epic-scoped lifecycle ledger still sees
  * the Story drop out.
  *
- * `runStoryReviewCore` is exported as the shared spine that the
- * `single-story-close` path imports, so both close paths call `runCodeReview`
- * through a single implementation rather than each maintaining its own
- * invocation pattern (Story #3653).
+ * The shared spine both close paths call `runCodeReview` through
+ * (`runStoryReviewCore`, Story #3653) and the shift-left local-lens pass
+ * (Epic #4405) live in `review-core.js` and `local-lens-review.js`
+ * respectively (extracted by Story #4603). This module is the Epic-attached
+ * phase entry point: it owns the advisory error posture and the
+ * critical-halt → blocked-envelope translation, and nothing else.
  */
 
-import {
-  runAuditSuite,
-  selectLocalLenses,
-} from '../../../audit-suite/index.js';
-import { gitSpawn } from '../../../git-utils.js';
 import { Logger } from '../../../Logger.js';
 import { runCodeReview } from '../../code-review.js';
 import { emitBlockedCloseResult } from '../emit-blocked.js';
+import { runLocalLensReview } from './local-lens-review.js';
+import { runStoryReviewCore } from './review-core.js';
 
 /**
- * The review depth the Story-scope local-lens pass runs at. Shift-left
- * (Epic #4405): local concerns are cheap to decide on a single Story's diff, so
- * the maker-blind Story-scope review runs its matched local lenses at `light`
- * depth here rather than paying a deeper pass at Epic close. Fixed for this
- * tier — it is not risk-scaled like the code-review pillar depth.
- */
-export const STORY_SCOPE_LENS_DEPTH = 'light';
-
-/**
- * Enumerate the files changed in the `baseRef...headRef` diff via
- * `git diff --name-only`. Best-effort: returns `[]` when the diff cannot be
- * enumerated (git failure, missing ref) and never throws, mirroring the
- * advisory posture of the surrounding review phase. Synchronous `gitSpawn`
- * (returns `{ status, stdout }`) is the same seam `code-review.js#countChangedFiles`
- * uses.
+ * Read a review envelope's severity counts, tolerating the partial envelope a
+ * misbehaving provider adapter can return. Pure.
  *
- * @param {{ baseRef: string, headRef: string, gitSpawnFn?: typeof gitSpawn }} args
- * @returns {string[]} Changed file paths, or `[]` on any failure.
+ * @param {object|null|undefined} reviewResult
+ * @returns {{ critical: number, high: number, medium: number, suggestion: number }}
  */
-export function enumerateChangedFiles({
-  baseRef,
-  headRef,
-  gitSpawnFn = gitSpawn,
-}) {
-  try {
-    const result = gitSpawnFn(
-      process.cwd(),
-      'diff',
-      '--name-only',
-      `${baseRef}...${headRef}`,
-    );
-    if (!result || result.status !== 0 || typeof result.stdout !== 'string') {
-      return [];
+function resolveSeverity(reviewResult) {
+  return (
+    reviewResult?.severity ?? {
+      critical: 0,
+      high: 0,
+      medium: 0,
+      suggestion: 0,
     }
-    return result.stdout
-      .split('\n')
-      .map((f) => f.trim())
-      .filter(Boolean);
-  } catch {
-    return [];
-  }
+  );
 }
 
 /**
- * Run the Story-scope local-lens pass: select the LOCAL-tier lenses whose
- * `filePatterns` match the actual Story diff (`baseRef...headRef`) and
- * materialize their lens-prompt bodies at `light` depth. This is the
- * shift-left tier from Epic #4405 — it runs **inside** the story-close
- * subprocess spine (called only from {@link runStoryReviewCore}), never in the
- * delivering child's (maker's) context, so a maker never grades its own work.
- *
- * A diff that matches no local lens adds **no** lens work: the roster is empty
- * and `runAuditSuite` is never invoked. Best-effort and total — a git or
- * materialization failure degrades to `{ skipped: true, lenses: [] }` and is
- * logged via `progress`, matching the advisory posture the review phase already
- * takes for provider/transport failures.
+ * Collect the extra fields for the code-review-critical blocked envelope. Pure.
  *
- * @param {{
- *   baseRef: string,
- *   headRef: string,
- *   progress: (tag: string, msg: string) => void,
- *   progressTag?: string,
- *   gitSpawnFn?: typeof gitSpawn,
- *   selectLocalLensesFn?: typeof selectLocalLenses,
- *   runAuditSuiteFn?: typeof runAuditSuite,
- * }} args
- * @returns {Promise<{
- *   depth: 'light',
- *   lenses: string[],
- *   skipped: boolean,
- *   materialized: object|null,
- * }>}
- */
-export async function runLocalLensReview({
-  baseRef,
-  headRef,
-  progress,
-  progressTag = 'CODE-REVIEW',
-  gitSpawnFn = gitSpawn,
-  selectLocalLensesFn = selectLocalLenses,
-  runAuditSuiteFn = runAuditSuite,
-}) {
-  const empty = {
-    depth: STORY_SCOPE_LENS_DEPTH,
-    lenses: [],
-    skipped: true,
-    materialized: null,
-  };
-  let lenses;
-  try {
-    const changedFiles = enumerateChangedFiles({
-      baseRef,
-      headRef,
-      gitSpawnFn,
-    });
-    lenses = selectLocalLensesFn({ changedFiles });
-    if (lenses.length === 0) {
-      progress(
-        progressTag,
-        'No local lens matched the Story diff — skipping the lens pass.',
-      );
-      return empty;
-    }
-    const materialized = await runAuditSuiteFn({ auditWorkflows: lenses });
-    progress(
-      progressTag,
-      `Ran ${lenses.length} local lens(es) at ${STORY_SCOPE_LENS_DEPTH} depth: ${lenses.join(', ')}.`,
-    );
-    return {
-      depth: STORY_SCOPE_LENS_DEPTH,
-      lenses,
-      skipped: false,
-      materialized,
-    };
-  } catch (err) {
-    // The lens pass is advisory: a git or materialization failure must not
-    // fail the close. Log and degrade to a skipped envelope.
-    progress(
-      progressTag,
-      `⚠️ local lens pass failed (continuing without it): ${err?.message ?? err}`,
-    );
-    return empty;
-  }
-}
-
-/**
- * Collect the extra fields for the code-review-critical blocked envelope.
- * Pure; used by `runStoryCodeReview` to populate the `extra` argument of
- * `emitBlockedCloseResult`.
+ * @param {{ storyId: number, reviewResult: object }} args
+ * @returns {object}
  */
 function buildCodeReviewBlockedExtra({ storyId, reviewResult }) {
-  const severity = reviewResult?.severity ?? {
-    critical: 0,
-    high: 0,
-    medium: 0,
-    suggestion: 0,
-  };
   return {
-    storyId: Number(storyId),
+    storyId,
     blockerReason: reviewResult?.blockerReason ?? null,
-    severity,
+    severity: resolveSeverity(reviewResult),
     posted: reviewResult?.posted ?? false,
     exitCode: 1,
   };
 }
 
 /**
- * Invoke `runCodeReviewFn` with the canonical Story-scope envelope and return
- * the raw result. Shared by both the Epic-attached close path
- * (`runStoryCodeReview`) and the standalone close path
- * (`single-story-close/phases/code-review.js#runStoryScopeReview`) so the
- * invocation pattern lives in one place (Story #3653).
- *
- * The caller is responsible for error handling and result interpretation —
- * this function propagates throws rather than swallowing them, because the
- * two callers have different advisory postures:
+ * Render the operator-facing one-line summary of a completed (non-halting)
+ * review. Pure.
  *
- *   - Epic-attached close: swallows throws (non-blocking advisory, same as
- *     `refresh.js`).
- *   - Standalone close: propagates throws (a review failure stops the close).
+ * @param {object} reviewResult
+ * @returns {string}
+ */
+function formatReviewSummary(reviewResult) {
+  const { high, medium, suggestion } = resolveSeverity(reviewResult);
+  const posted = reviewResult?.posted ?? false;
+  return `Review complete — high=${high} medium=${medium} suggestion=${suggestion} (posted=${posted}).`;
+}
+
+/**
+ * Run the shared review spine, absorbing an adapter / wiring failure into this
+ * phase's advisory posture: the review is best-effort when the provider cannot
+ * complete, and the gates already vouched for the diff at this point.
  *
- * Review depth is not passed in: `runCodeReview` derives it entirely from the
- * `baseRef...headRef` diff it enumerates itself — the changed files' sensitive-
- * path intersection plus their count (Story #4542, which retired the
- * planner-authored risk envelope this spine used to forward). Depth remains an
- * **input-only** signal: it tells the provider how thorough to be and never
- * alters the review's output envelope or the posted structured-comment body.
+ * @param {object} args Spine arguments (see {@link runStoryReviewCore}).
+ * @returns {Promise<object|null>} The review envelope, or `null` when the
+ *   review threw and the close should proceed unblocked.
+ */
+async function invokeReviewCore(args) {
+  try {
+    return await runStoryReviewCore(args);
+  } catch (err) {
+    Logger.warn?.(
+      `[story-close] ⚠️ code-review phase failed (continuing without blocker): ${err?.message ?? err}`,
+    );
+    return null;
+  }
+}
+
+/**
+ * Translate a halting (critical-findings) review into the blocked envelope the
+ * caller returns verbatim, emitting `story.blocked` onto the bus on the way.
  *
  * @param {{
- *   storyId: number|string,
- *   baseRef: string,
- *   headRef: string,
- *   commentTargetId?: number|null,
- *   provider: object,
+ *   storyId: number,
+ *   reviewResult: object,
+ *   bus: { emit: Function }|null,
  *   progress: (tag: string, msg: string) => void,
- *   progressTag?: string,
- *   runCodeReviewFn?: typeof runCodeReview,
- *   runLocalLensReviewFn?: typeof runLocalLensReview,
  * }} args
- * @returns {Promise<object>} Raw result envelope from `runCodeReview`, augmented
- *   with a `localLensReview` field carrying the Story-scope local-lens pass
- *   outcome (Epic #4405, Story #4409). Both close entry points reach the lens
- *   pass through this single spine, so it runs on the Epic-attached and
- *   standalone paths alike and always inside the close subprocess.
+ * @returns {Promise<object>} The blocked envelope.
  */
-export async function runStoryReviewCore({
-  storyId,
-  baseRef,
-  headRef,
-  commentTargetId = null,
-  provider,
-  progress,
-  progressTag = 'CODE-REVIEW',
-  runCodeReviewFn = runCodeReview,
-  runLocalLensReviewFn = runLocalLensReview,
-}) {
-  const storyIdNum = Number(storyId);
-  const opts = {
-    scope: 'story',
-    ticketId: storyIdNum,
-    baseRef,
-    headRef,
-    provider,
-    logger: {
-      info: (m) => progress(progressTag, m),
-      warn: (m) => progress(progressTag, `⚠️ ${m}`),
-    },
-  };
-  if (commentTargetId != null) {
-    opts.commentTargetId = commentTargetId;
-  }
-
-  // Shift-left local-lens pass (Epic #4405). Runs matched local lenses at
-  // `light` depth against the actual Story diff, inside this close-subprocess
-  // spine so the maker never grades its own work. Advisory — it never blocks
-  // the close and its outcome rides on the returned envelope for downstream
-  // consumers.
-  const localLensReview = await runLocalLensReviewFn({
-    baseRef,
-    headRef,
+async function emitCriticalBlock({ storyId, reviewResult, bus, progress }) {
+  const { critical } = resolveSeverity(reviewResult);
+  return emitBlockedCloseResult({
+    storyId,
+    phase: 'closing',
+    reason: 'code-review-critical',
+    extra: buildCodeReviewBlockedExtra({ storyId, reviewResult }),
+    bus,
     progress,
-    progressTag,
+    blockedMessage: `Story #${storyId} blocked: code-review reported ${critical} critical blocker(s).`,
+    logger: Logger,
   });
-
-  const result = await runCodeReviewFn(opts);
-  return { ...result, localLensReview };
 }
 
 /**
@@ -301,65 +164,44 @@ export async function runStoryReviewCore({
  *   (Epic #4405, Story #4409) when the review completed; it is absent only when
  *   the whole review phase threw (advisory failure).
  */
-export async function runStoryCodeReview(args) {
-  const {
-    storyId,
-    baseBranch,
-    storyBranch,
-    provider,
-    bus,
-    progress,
-    runCodeReviewFn = runCodeReview,
-    runLocalLensReviewFn = runLocalLensReview,
-  } = args;
-
+export async function runStoryCodeReview({
+  storyId,
+  baseBranch,
+  storyBranch,
+  provider,
+  bus,
+  progress,
+  runCodeReviewFn = runCodeReview,
+  runLocalLensReviewFn = runLocalLensReview,
+}) {
   const storyIdNum = Number(storyId);
   progress(
     'CODE-REVIEW',
     `Running Story-scope review (${baseBranch}…${storyBranch})...`,
   );
 
-  let reviewResult;
-  try {
-    reviewResult = await runStoryReviewCore({
-      storyId: storyIdNum,
-      baseRef: baseBranch,
-      headRef: storyBranch,
-      provider,
-      progress,
-      runCodeReviewFn,
-      runLocalLensReviewFn,
-    });
-  } catch (err) {
-    // Adapter / wiring failure — log and proceed. The review is advisory
-    // when the provider cannot complete; the gates already vouched for
-    // the diff at this point.
-    Logger.warn?.(
-      `[story-close] ⚠️ code-review phase failed (continuing without blocker): ${err?.message ?? err}`,
-    );
-    return { blocked: null };
-  }
-
-  const localLensReview = reviewResult?.localLensReview;
+  const reviewResult = await invokeReviewCore({
+    storyId: storyIdNum,
+    baseRef: baseBranch,
+    headRef: storyBranch,
+    provider,
+    progress,
+    runCodeReviewFn,
+    runLocalLensReviewFn,
+  });
+  if (reviewResult === null) return { blocked: null };
 
-  if (reviewResult?.halted) {
-    const blocked = await emitBlockedCloseResult({
+  const localLensReview = reviewResult.localLensReview;
+  if (reviewResult.halted) {
+    const blocked = await emitCriticalBlock({
       storyId: storyIdNum,
-      phase: 'closing',
-      reason: 'code-review-critical',
-      extra: buildCodeReviewBlockedExtra({ storyId: storyIdNum, reviewResult }),
+      reviewResult,
       bus,
       progress,
-      blockedMessage: `Story #${storyIdNum} blocked: code-review reported ${reviewResult.severity.critical} critical blocker(s).`,
-      logger: Logger,
     });
     return { blocked, localLensReview };
   }
 
-  const counts = reviewResult?.severity ?? {};
-  progress(
-    'CODE-REVIEW',
-    `Review complete — high=${counts.high ?? 0} medium=${counts.medium ?? 0} suggestion=${counts.suggestion ?? 0} (posted=${reviewResult?.posted ?? false}).`,
-  );
+  progress('CODE-REVIEW', formatReviewSummary(reviewResult));
   return { blocked: null, localLensReview };
 }