@beyondwork/docx-react-component 1.0.83 → 1.0.85

package/src/runtime/formatting/field/resolver.ts

@@ -13,7 +13,9 @@ import type {
   ParagraphNode,
   StylesCatalog,
 } from "../../../model/canonical-document.ts";
+import { resolvePageFieldDisplayText } from "../../layout/resolve-page-fields.ts";
 import type { RuntimePageGraph, RuntimePageNode } from "../../layout/page-graph.ts";
+import { formatPageNumber } from "./page-number-format.ts";
 
 /**
  * Layer-03 alias for the layout module's `RuntimePageGraph`. Exists so
@@ -80,7 +82,11 @@ export function createFieldResolver(input: FieldResolverInput): FieldResolver {
           return { displayText: "", refreshStatus: "unresolvable" };
         }
         return {
-          displayText: String(page.stories.displayPageNumber),
+          displayText: resolvePageFieldDisplayText(
+            "PAGE",
+            entry.displayText ?? "",
+            { page, graph: pageGraph },
+          ),
           refreshStatus: "current",
         };
       }
@@ -90,7 +96,34 @@ export function createFieldResolver(input: FieldResolverInput): FieldResolver {
           return { displayText: "", refreshStatus: "unresolvable" };
         }
         return {
-          displayText: String(pageGraph.contentPageCount),
+          displayText: resolvePageFieldDisplayText(
+            "NUMPAGES",
+            entry.displayText ?? "",
+            { page: pageGraph.pages[activePageIndex] ?? pageGraph.pages[0]!, graph: pageGraph },
+          ),
+          refreshStatus: "current",
+        };
+      }
+
+      case "SECTIONPAGES": {
+        const page = pageGraph.pages[activePageIndex];
+        if (!page) {
+          return { displayText: "", refreshStatus: "unresolvable" };
+        }
+        const sectionPageCount = pageGraph.pages.filter(
+          (candidate) =>
+            !candidate.isBlankFiller &&
+            candidate.sectionIndex === page.sectionIndex,
+        ).length;
+        if (sectionPageCount === 0) {
+          return { displayText: "", refreshStatus: "unresolvable" };
+        }
+        return {
+          displayText: resolvePageFieldDisplayText(
+            "SECTIONPAGES",
+            entry.displayText ?? "",
+            { page, graph: pageGraph },
+          ),
           refreshStatus: "current",
         };
       }
@@ -125,7 +158,7 @@ export function createFieldResolver(input: FieldResolverInput): FieldResolver {
           return { displayText: "", refreshStatus: "unresolvable" };
         }
         return {
-          displayText: String(page.stories.displayPageNumber),
+          displayText: resolvePageGraphFieldText("PAGE", page, pageGraph),
           refreshStatus: "current",
           ...(entry.switches?.hyperlink ? { asHyperlink: true as const } : {}),
         };
@@ -182,18 +215,16 @@ export function createFieldResolver(input: FieldResolverInput): FieldResolver {
         return undefined;
 
       case "NOTEREF":
-      case "SECTIONPAGES":
-        // These families are classified as SupportedFieldFamily (see
+        // NOTEREF is classified as SupportedFieldFamily (see
         // `src/model/canonical-document.ts::SupportedFieldFamily`) but
-        // are NOT implemented in the resolver yet. Returning
+        // is NOT implemented in the resolver yet. Returning
         // `refreshStatus: "unresolvable"` is the honest answer — the
         // caller knows the family is recognized but the runtime has
         // no resolution path. This distinguishes them from TOC
         // (intentional `undefined` = preserve existing display) and
         // from PreserveOnlyFieldFamily (parse-only, no refresh slot).
         // Tracked in L03 audit 2026-04-22 as Task-4 follow-up: implement
-        // NOTEREF via footnote/endnote anchor lookup + SECTIONPAGES via
-        // pageGraph section-scoped page-count walk.
+        // NOTEREF via footnote/endnote anchor lookup.
         return { displayText: "", refreshStatus: "unresolvable" };
 
       default:
@@ -248,6 +279,40 @@ function findPageForOffset(
   return result;
 }
 
+function resolvePageGraphFieldText(
+  family: "PAGE" | "NUMPAGES" | "SECTIONPAGES",
+  page: RuntimePageNode,
+  graph: RuntimePageGraph,
+): string {
+  switch (family) {
+    case "PAGE":
+      return formatPageNumber(
+        page.stories.displayPageNumber,
+        page.layout?.pageNumbering?.format,
+      );
+    case "NUMPAGES":
+      return String(graph.contentPageCount);
+    case "SECTIONPAGES":
+      return formatPageNumber(
+        countContentPagesInSection(graph, page.sectionIndex),
+        page.layout?.pageNumbering?.format,
+      );
+  }
+}
+
+function countContentPagesInSection(
+  graph: RuntimePageGraph,
+  sectionIndex: number,
+): number {
+  let count = 0;
+  for (const page of graph.pages) {
+    if (page.sectionIndex === sectionIndex && !page.isBlankFiller) {
+      count += 1;
+    }
+  }
+  return count;
+}
+
 /**
  * Walk paragraphs in document order and invoke `visit` for each one.
  * Tables are traversed via their `rows` arrays, cells via their `children`.

package/src/runtime/layout/layout-engine-version.ts

@@ -948,15 +948,7 @@
  *   invalidate because any future document with a real body framePr
  *   paginates differently.
  *
- *  56 — perf(11b,07) `8d07de1b` multi-range viewport realization.
- *   `WordReviewEditorLayoutFacet` gained `setVisibleBlockRanges` for
- *   multi-range viewport realization (paired with coord-07 §2.9
- *   `runtime.viewport.subscribe`). The contract widened but the
- *   underlying layout algorithm is unchanged — persisted envelopes
- *   remain shape-compatible. Bump is defensive so any consumer that
- *   keyed on the facet contract refreshes the cache.
- *
- *  57 — viewport-cull flicker fix. The pre-v57 PM placeholder emitted
+ *  56 — viewport-cull flicker fix. The pre-v56 PM placeholder emitted
  *   for `placeholder-culled` opaque blocks rendered at
  *   `min-height: 20px` regardless of the real block's visual height
  *   (`src/ui-tailwind/editor-surface/pm-schema.ts`), because neither
@@ -978,11 +970,38 @@
  *   fallback when the attr is set.
  *
  *   Pagination itself is untouched — this is purely a render-surface
- *   fix. Cache envelopes from v56 invalidate because the exposed
+ *   fix. Cache envelopes from v55 invalidate because the exposed
  *   facet surface grew one public method; any consumer relying on
- *   the prior interface shape re-derives its cache key under v57.
+ *   the prior interface shape re-derives its cache key under v56.
+ *
+ *  57 — canvas pagination seam polish. The canvas-posture page-break
+ *   widget no longer renders the `N / M` pagination marker as a rounded
+ *   bubble/card. It now paints only the dotted seam line plus plain
+ *   page-number text (`data-kind="canvas-seam-page-number"`), removing
+ *   the old background, border, radius, and shadow from the widget DOM.
+ *   Pagination geometry is unchanged, but cached render-frame DOM
+ *   snapshots from v56 must invalidate because the widget shape changed.
+ *
+ *  58 — pagination honors style-derived paragraph flow flags where they
+ *   are strong enough to affect page assignment. The paginated layout
+ *   pass promotes cascaded `keepNext` only when the paragraph is also
+ *   resolved with `keepLines` (direct `keepNext` is unchanged). This
+ *   matches the built-in heading pattern used by the SOW redline pages
+ *   without letting keep-next-only legal template headings or custom
+ *   style page-break hints broadly over-paginate the CCEP corpus. Cache
+ *   envelopes from v57 invalidate because page assignment can change for
+ *   style-driven docs.
+ *
+ *  59 — page-field resolver reads from `public-facet`'s page-graph
+ *   truth (`a9969e97`). `public-facet.ts` gained
+ *   `getStoryBlocksForRegion(regionIndex): ReadonlyArray<BlockId>`
+ *   and `resolve-page-fields.ts` was rewritten to consume it instead
+ *   of the older cached resolver state that could go stale after
+ *   layout changes. The facet contract widened by one public method —
+ *   persisted cache envelopes from v58 must re-derive their page-field
+ *   projections.
  */
-export const LAYOUT_ENGINE_VERSION = 57 as const;
+export const LAYOUT_ENGINE_VERSION = 59 as const;
 
 /**
  * Serialization schema version for the LayCache payload (the cache envelope

package/src/runtime/layout/paginated-layout-engine.ts

@@ -1637,36 +1637,43 @@ export function paginateSectionBlocksWithSplits(
         index,
       );
 
+      const formatting = block.kind === "paragraph"
+        ? resolveBlockFormatting(block, defaultTabInterval, themeFonts)
+        : null;
+      const keepLinesActive = formatting?.keepLines ?? false;
+      const keepNextActive = block.kind === "paragraph"
+        ? Boolean(block.keepNext ?? (block.resolvedParagraphFormatting?.keepNext && keepLinesActive))
+        : false;
+      const pageBreakBeforeActive = block.kind === "paragraph"
+        ? Boolean(block.pageBreakBefore)
+        : false;
+
       // keepNext: this paragraph must stay with the next one on the same page
+      const nextBlock = blocks[index + 1];
       const keepWithNextHeight =
-        block.kind === "paragraph" && block.keepNext
+        block.kind === "paragraph" && keepNextActive && nextBlock
           ? baseHeight +
             applyContextualSpacingAdjustment(
               measureBlockHeight(
-                blocks[index + 1],
+                nextBlock,
                 columnWidth,
                 measurementProvider,
                 cache,
                 defaultTabInterval,
                 themeFonts,
               ),
-              blocks[index + 1],
+              nextBlock,
               index + 1,
             )
           : baseHeight;
 
       // keepLines: the entire paragraph must fit on one page.
       // If it doesn't fit and there's already content on this page, break before it.
-      const formatting = block.kind === "paragraph"
-        ? resolveBlockFormatting(block, defaultTabInterval, themeFonts)
-        : null;
-      const keepLinesActive = formatting?.keepLines ?? false;
-
       const noteHeight = estimateFootnoteReservation(block, footnotes, columnWidth, reservedNotes);
       const projectedHeight = columnHeight + keepWithNextHeight + reservedNoteHeight + noteHeight;
 
       // pageBreakBefore
-      if (block.kind === "paragraph" && block.pageBreakBefore && pageStart < block.from) {
+      if (block.kind === "paragraph" && pageBreakBeforeActive && pageStart < block.from) {
         pushPage(block.from);
         continue;
       }
@@ -1785,7 +1792,7 @@ export function paginateSectionBlocksWithSplits(
           block.kind === "paragraph" &&
           formatting &&
           !keepLinesActive &&
-          !block.keepNext
+          !keepNextActive
         ) {
           const availableHeight = usableHeight - columnHeight - reservedNoteHeight;
           const cachedLineCount = cache?.getLineCount(block, columnWidth);
@@ -1809,7 +1816,7 @@ export function paginateSectionBlocksWithSplits(
             availableLines,
             keepLines: keepLinesActive,
             widowControl: formatting.widowControl,
-            keepNext: Boolean(block.keepNext),
+            keepNext: keepNextActive,
             isLastBlockOnPage: index === blocks.length - 1,
           });
           if (splitRule) {

package/src/runtime/layout/public-facet.ts

@@ -77,6 +77,7 @@ import {
 import { createFormattingContext } from "../formatting/formatting-context.ts";
 import type { ResolvedTableStyleResolution } from "../formatting/table-style-resolver.ts";
 import { buildTableRenderPlan } from "./table-render-plan.ts";
+import { resolvePageFieldDisplayText } from "./resolve-page-fields.ts";
 // Geometry helpers are no longer imported here:
 //  - `hitTest` + `getAnchorRects` moved to the geometry facet in the
 //    refactor/05 Slice 6 wrapper-deletion pass (2026-04-22).
@@ -90,6 +91,7 @@ import { collectLineBoxesForRegion } from "../geometry/project-fragments.ts";
 // can add its own instrumentation at call site if needed.
 import type {
   SurfaceBlockSnapshot,
+  SurfaceInlineSegment,
 } from "../../api/public-types";
 
 export type {
@@ -828,9 +830,14 @@ export function createLayoutFacet(
       if (!story) return Object.freeze([]);
       // P8.2.1 — share the projected `SurfaceBlockSnapshot[]` across every
       // page that renders the same story target.
-      const projectedBlocks = getStoryProjectionCached(story, document);
+      const projectedBlocks = resolvePageScopedFieldsInBlocks(
+        getStoryProjectionCached(story, document),
+        node,
+        graph,
+      );
       return resolveHeaderFooterRegionBlocks(
-        node.pageIndex,
+        node,
+        graph,
         region,
         story,
         projectedBlocks,
@@ -1866,7 +1873,8 @@ function resolveColumnRegionBlocks(
 }
 
 function resolveHeaderFooterRegionBlocks(
-  pageIndex: number,
+  node: RuntimePageNode,
+  graph: RuntimePageGraph,
   regionKind: "header" | "footer",
   storyTarget: EditorStoryTarget,
   projectedBlocks: readonly SurfaceBlockSnapshot[],
@@ -1875,21 +1883,117 @@ function resolveHeaderFooterRegionBlocks(
   if (projectedBlocks.length === 0) return Object.freeze([]);
   const fragmentBase = `story-${storyTarget.kind}-${storyTarget.relationshipId}-${storyTarget.variant}-${storyTarget.sectionIndex ?? "_"}`;
   return Object.freeze(
-    projectedBlocks.map((blockSnapshot, index): PublicRegionBlock => ({
-      blockId: blockSnapshot.blockId,
-      fragmentId: `${fragmentBase}-${index}`,
-      pageIndex,
-      regionKind,
-      runtimeFromOffset: blockSnapshot.from,
-      runtimeToOffset: blockSnapshot.to,
-      // Header/footer fragments aren't measured per-block — consumers read
-      // the region's `heightTwips` from `getStoryRegionsOnPage`.
-      heightTwips: 0,
-      blockSnapshot,
-    })),
+    projectedBlocks.map((blockSnapshot, index): PublicRegionBlock => {
+      const resolvedBlockSnapshot = resolvePageInstanceFieldsInBlock(
+        blockSnapshot,
+        node,
+        graph,
+      );
+      return {
+        blockId: blockSnapshot.blockId,
+        fragmentId: `${fragmentBase}-${index}`,
+        pageIndex: node.pageIndex,
+        regionKind,
+        runtimeFromOffset: blockSnapshot.from,
+        runtimeToOffset: blockSnapshot.to,
+        // Header/footer fragments aren't measured per-block — consumers read
+        // the region's `heightTwips` from `getStoryRegionsOnPage`.
+        heightTwips: 0,
+        blockSnapshot: resolvedBlockSnapshot,
+      };
+    }),
   );
 }
 
+const PAGE_INSTANCE_FIELD_FAMILIES = new Set([
+  "PAGE",
+  "NUMPAGES",
+  "SECTIONPAGES",
+]);
+
+function resolvePageScopedFieldsInBlocks(
+  blocks: readonly SurfaceBlockSnapshot[],
+  page: RuntimePageNode,
+  graph: RuntimePageGraph,
+): readonly SurfaceBlockSnapshot[] {
+  let changed = false;
+  const resolvedBlocks = blocks.map((block) => {
+    const resolved = resolvePageInstanceFieldsInBlock(block, page, graph);
+    if (resolved !== block) changed = true;
+    return resolved;
+  });
+  return changed ? resolvedBlocks : blocks;
+}
+
+function resolvePageInstanceFieldsInBlock(
+  block: SurfaceBlockSnapshot,
+  page: RuntimePageNode,
+  graph: RuntimePageGraph,
+): SurfaceBlockSnapshot {
+  switch (block.kind) {
+    case "paragraph": {
+      const segments = resolvePageInstanceFieldsInSegments(block.segments, page, graph);
+      return segments === block.segments ? block : { ...block, segments };
+    }
+    case "table": {
+      let changed = false;
+      const rows = block.rows.map((row) => {
+        let rowChanged = false;
+        const cells = row.cells.map((cell) => {
+          let cellChanged = false;
+          const content = cell.content.map((child) => {
+            const resolved = resolvePageInstanceFieldsInBlock(child, page, graph);
+            if (resolved !== child) cellChanged = true;
+            return resolved;
+          });
+          if (!cellChanged) return cell;
+          rowChanged = true;
+          return { ...cell, content };
+        });
+        if (!rowChanged) return row;
+        changed = true;
+        return { ...row, cells };
+      });
+      return changed ? { ...block, rows } : block;
+    }
+    case "sdt_block": {
+      let changed = false;
+      const children = block.children.map((child) => {
+        const resolved = resolvePageInstanceFieldsInBlock(child, page, graph);
+        if (resolved !== child) changed = true;
+        return resolved;
+      });
+      return changed ? { ...block, children } : block;
+    }
+    default:
+      return block;
+  }
+}
+
+function resolvePageInstanceFieldsInSegments(
+  segments: SurfaceInlineSegment[],
+  page: RuntimePageNode,
+  graph: RuntimePageGraph,
+): SurfaceInlineSegment[] {
+  let changed = false;
+  const resolvedSegments = segments.map((segment) => {
+    if (segment.kind !== "field_ref" || !PAGE_INSTANCE_FIELD_FAMILIES.has(segment.fieldFamily)) {
+      return segment;
+    }
+    const displayText = resolvePageFieldDisplayText(
+      segment.fieldFamily,
+      segment.displayText ?? segment.label,
+      { page, graph },
+    );
+    if (segment.displayText === displayText && segment.refreshStatus === "current") {
+      return segment;
+    }
+    changed = true;
+    return { ...segment, displayText, refreshStatus: "current" as const };
+  });
+  return changed ? resolvedSegments : segments;
+}
+
 function resolveFootnoteAreaRegionBlocks(
   node: RuntimePageNode,
   document: CanonicalDocumentEnvelope,
@@ -1945,4 +2049,3 @@ function resolveFootnoteAreaRegionBlocks(
   }
   return Object.freeze(blocks);
 }
-

package/src/runtime/layout/resolve-page-fields.ts

@@ -1,5 +1,5 @@
 /**
- * Resolve `PAGE` and `NUMPAGES` field values per page.
+ * Resolve `PAGE`, `NUMPAGES`, and `SECTIONPAGES` field values per page.
  *
  * These two field families (now in `SupportedFieldFamily`) compute differently
  * from `REF` / `PAGEREF` because the resolved value depends on the *owning
@@ -13,8 +13,10 @@
  * preserve-only text that currently sits inside the paragraph inline atom.
  */
 
-import type { RuntimePageGraph, RuntimePageNode } from "./page-graph.ts";
 import type { SupportedFieldFamily } from "../../model/canonical-document.ts";
+import { formatPageNumber } from "../formatting/field/page-number-format.ts";
+import type { PublicPageNode } from "./public-facet.ts";
+import type { RuntimePageGraph, RuntimePageNode } from "./page-graph.ts";
 
 export interface PageFieldContext {
   /** The page this header/footer copy renders on. */
@@ -23,8 +25,16 @@ export interface PageFieldContext {
   graph: RuntimePageGraph;
 }
 
+export interface PublicPageFieldContext {
+  /** The page this header/footer copy renders on. */
+  page: PublicPageNode;
+  /** All pages from the same layout facet snapshot. */
+  pages: readonly PublicPageNode[];
+}
+
 /**
- * Resolve the display text for a PAGE / NUMPAGES field on a specific page.
+ * Resolve the display text for a PAGE / NUMPAGES / SECTIONPAGES field on a
+ * specific runtime page.
  *
  * Returns the original cached `displayText` for unsupported families so the
  * caller can use this as a single resolution helper.
@@ -36,11 +46,54 @@ export function resolvePageFieldDisplayText(
 ): string {
   switch (family) {
     case "PAGE":
-      return String(context.page.stories.displayPageNumber);
+      return formatPageNumber(
+        context.page.stories.displayPageNumber,
+        context.page.layout?.pageNumbering?.format,
+      );
     case "NUMPAGES":
       // Blank fillers (evenPage/oddPage section breaks) don't count toward
       // NUMPAGES — the graph already excludes them from contentPageCount.
-      return String(context.graph.contentPageCount);
+      return formatPageNumber(
+        context.graph.contentPageCount,
+        context.page.layout?.pageNumbering?.format,
+      );
+    case "SECTIONPAGES":
+      return formatPageNumber(
+        countRuntimeSectionContentPages(context.graph, context.page.sectionIndex),
+        context.page.layout?.pageNumbering?.format,
+      );
+    default:
+      return cachedDisplayText;
+  }
+}
+
+/**
+ * Public-facet equivalent used by page-stack chrome. Header/footer parts are
+ * shared stories, but each visible page copy needs its own page-field text.
+ */
+export function resolvePublicPageFieldDisplayText(
+  family: SupportedFieldFamily | string,
+  cachedDisplayText: string,
+  context: PublicPageFieldContext,
+): string {
+  switch (family) {
+    case "PAGE":
+      return formatPageNumber(
+        context.page.displayPageNumber,
+        context.page.layout.pageNumbering?.format,
+      );
+    case "NUMPAGES":
+      return formatPageNumber(
+        context.pages.filter((page) => !page.isBlankFiller).length,
+        context.page.layout.pageNumbering?.format,
+      );
+    case "SECTIONPAGES":
+      return formatPageNumber(
+        context.pages.filter(
+          (page) => !page.isBlankFiller && page.sectionIndex === context.page.sectionIndex,
+        ).length,
+        context.page.layout.pageNumbering?.format,
+      );
     default:
       return cachedDisplayText;
   }
@@ -53,7 +106,7 @@ export function resolvePageFieldDisplayText(
  */
 export function buildPageFieldResolutionTable(
   graph: RuntimePageGraph,
-  families: ReadonlySet<string> = new Set(["PAGE", "NUMPAGES"]),
+  families: ReadonlySet<string> = new Set(["PAGE", "NUMPAGES", "SECTIONPAGES"]),
 ): Map<string, Map<string, string>> {
   const result = new Map<string, Map<string, string>>();
   for (const page of graph.pages) {
@@ -68,3 +121,12 @@ export function buildPageFieldResolutionTable(
   }
   return result;
 }
+
+function countRuntimeSectionContentPages(
+  graph: RuntimePageGraph,
+  sectionIndex: number,
+): number {
+  return graph.pages.filter(
+    (page) => !page.isBlankFiller && page.sectionIndex === sectionIndex,
+  ).length;
+}

package/src/runtime/layout/resolve-page-previews.ts

@@ -140,7 +140,7 @@ function collectInlineText(
     case "field": {
       const family = inline.fieldFamily ?? classifyFieldInstructionLocal(inline.instruction);
       const cached = flattenInline(inline.children);
-      if (family === "PAGE" || family === "NUMPAGES") {
+      if (family === "PAGE" || family === "NUMPAGES" || family === "SECTIONPAGES") {
         out.push(
           resolvePageFieldDisplayText(family, cached, { page, graph }),
         );

package/src/runtime/scopes/_scope-dependencies.ts

@@ -37,6 +37,7 @@ export type {
   WorkflowMetadataSnapshot,
   WorkflowOverlay,
   WorkflowScope,
+  WorkflowScopeGuardPolicy,
   WorkflowScopeMetadataField,
 } from "../../api/public-types.ts";
 

package/src/runtime/scopes/action-validation.ts

@@ -204,55 +204,64 @@ function collectGuardVerdict(
   }
 
   const guard = runtime.getInteractionGuardSnapshot();
-  if (
-    guard.effectiveMode === "view" &&
-    !blockedReasons.includes("guard:view-mode-active")
-  ) {
-    blockedReasons.push("guard:view-mode-active");
+  // Scope-targeted writes target `scope.handle.scopeId`, not the current
+  // editor selection. The target scope's own overlay posture was handled
+  // above through `scope.workflow.effectiveMode`; this second guard read is
+  // only allowed to contribute global/session-wide blockers.
+  const isSelectionScopeMembershipReason = (reason: { readonly code: string; readonly scopeId?: string }): boolean => {
+    if (reason.code === "outside_workflow_scope") return true;
+    if (
+      (reason.code === "workflow_view_only" ||
+        reason.code === "workflow_comment_only") &&
+      typeof reason.scopeId === "string" &&
+      reason.scopeId.length > 0
+    ) {
+      return true;
+    }
+    return false;
+  };
+  const rawReasons = guard.blockedReasons ?? [];
+  const nonSelectionScoped = rawReasons.filter(
+    (r) => !isSelectionScopeMembershipReason(r),
+  );
+  const pushTypedGuardBlocker = (code: string | undefined): void => {
+    const suffix = typeof code === "string" && code.length > 0
+      ? code
+      : "unspecified";
+    const typedBlocker = `guard:block-${suffix}`;
+    if (!blockedReasons.some((existing) => existing === typedBlocker)) {
+      blockedReasons.push(typedBlocker);
+    }
+  };
+  if (guard.effectiveMode === "view") {
+    const globalViewReason = nonSelectionScoped.find(
+      (reason) => reason.code === "workflow_view_only",
+    );
+    if (globalViewReason) {
+      pushTypedGuardBlocker(globalViewReason.code);
+    } else if (
+      rawReasons.length === 0 &&
+      !blockedReasons.includes("guard:view-mode-active")
+    ) {
+      blockedReasons.push("guard:view-mode-active");
+    }
+  }
+  if (guard.effectiveMode === "comment") {
+    const globalCommentReason = nonSelectionScoped.find(
+      (reason) => reason.code === "workflow_comment_only",
+    );
+    if (globalCommentReason) {
+      pushTypedGuardBlocker(globalCommentReason.code);
+    }
   }
   if (guard.effectiveMode === "blocked") {
     // Coord-06 §13e — promote the bare `guard:blocked` blocker to a typed
-    // `guard:block-<reason>` suffix so agents can route intelligently on
-    // boundary-paragraph / system-paragraph / read-only / protected-range
-    // situations. The specific sub-reason is the first NON-selection-
-    // scope-membership reason.
-    //
-    // Scope-targeted-write carve-out (coord-09, TemplateViewer repro
-    // 2026-04-24): `applyReplacementScope`, `attachExplanation`, and
-    // `createIssue` target a scopeId, not the current editor selection.
-    // The scope's own `workflow.effectiveMode` already drove the
-    // scope-level arm of `collectGuardVerdict` above (lines 159–197).
-    // The selection-scoped coordinator guard, in contrast, evaluates
-    // against the live `state.selection` — which, for scope-targeted
-    // writes, may sit anywhere in the document. Reasons that depend on
-    // selection-scope membership (`outside_workflow_scope`,
-    // `workflow_view_only`, `workflow_comment_only`) are therefore
-    // double-counting and must not block. Globally-scoped reasons
-    // (`document_read_only`, `document_viewing_mode`) still apply — a
-    // read-only doc rejects every write, scope-targeted or not.
-    const SELECTION_SCOPE_MEMBERSHIP_CODES = new Set([
-      "outside_workflow_scope",
-      "workflow_view_only",
-      "workflow_comment_only",
-    ]);
-    const rawReasons = guard.blockedReasons ?? [];
-    const nonSelectionScoped = rawReasons.filter(
-      (r) => !SELECTION_SCOPE_MEMBERSHIP_CODES.has(r.code),
-    );
-    // If every reason was selection-scope-membership for a scope-
-    // targeted write, emit no blocker — the scope-level arm above is
-    // authoritative. The defensive empty-array fallback
-    // (guard:block-unspecified) still fires when the coordinator
-    // produced effectiveMode:"blocked" without any reasons at all.
+    // `guard:block-<reason>` suffix. Selection-membership reasons are
+    // intentionally ignored here; global/session reasons such as read-only,
+    // protected ranges, shared workflow locks, and unsupported suggesting
+    // commands remain blockers.
     if (nonSelectionScoped.length > 0 || rawReasons.length === 0) {
-      const primaryCode = nonSelectionScoped[0]?.code;
-      const suffix = typeof primaryCode === "string" && primaryCode.length > 0
-        ? primaryCode
-        : "unspecified";
-      const typedBlocker = `guard:block-${suffix}`;
-      if (!blockedReasons.some((existing) => existing === typedBlocker)) {
-        blockedReasons.push(typedBlocker);
-      }
+      pushTypedGuardBlocker(nonSelectionScoped[0]?.code);
     }
   }
   for (const reason of guard.blockedReasons ?? []) {