@beyondwork/docx-react-component 1.0.106 → 1.0.108

package/src/runtime/workflow/derived-scope-resolver.ts

@@ -22,11 +22,10 @@
  * `attachExplanation` / `createIssue` inputs, this resolver accepts
  * the override via the second argument.
  *
- * Non-paragraph kinds (table / table-row / table-cell / field /
- * comment-thread / revision) are not in scope for §13c — CLM hot-path
- * dominates paragraph / heading / list-item. Table-kind resolution is
- * straightforward to add later (the scopeId grammar is `table:<index>`)
- * but no consumer asks for it yet.
+ * Table-family scopeIds are also supported for metadata fallback. Their
+ * compiler ranges are synthetic subdivisions of the table block, so metadata
+ * anchors intentionally bind to the containing table block while preserving
+ * the exact `scopeId` on the metadata entry.
  */
 
 import type {
@@ -42,6 +41,16 @@ import {
   detectParagraphKind,
 } from "../../model/paragraph-scope-ids.ts";
 
+type TableFamilyScopeRef =
+  | { readonly kind: "table"; readonly blockIndex: number }
+  | { readonly kind: "row"; readonly blockIndex: number; readonly rowIndex: number }
+  | {
+      readonly kind: "cell";
+      readonly blockIndex: number;
+      readonly rowIndex: number;
+      readonly cellIndex: number;
+    };
+
 function inlineLength(node: InlineNode): number {
   switch (node.type) {
     case "text":
@@ -69,6 +78,38 @@ function paragraphLength(paragraph: ParagraphNode): number {
   );
 }
 
+function parseTableFamilyScopeId(scopeId: string): TableFamilyScopeRef | null {
+  const table = /^table:(\d+)$/.exec(scopeId);
+  if (table) return { kind: "table", blockIndex: Number(table[1]) };
+  const row = /^row:(\d+):(\d+)$/.exec(scopeId);
+  if (row) {
+    return {
+      kind: "row",
+      blockIndex: Number(row[1]),
+      rowIndex: Number(row[2]),
+    };
+  }
+  const cell = /^cell:(\d+):(\d+):(\d+)$/.exec(scopeId);
+  if (cell) {
+    return {
+      kind: "cell",
+      blockIndex: Number(cell[1]),
+      rowIndex: Number(cell[2]),
+      cellIndex: Number(cell[3]),
+    };
+  }
+  return null;
+}
+
+function tableRefExists(block: BlockNode, ref: TableFamilyScopeRef): boolean {
+  if (block.type !== "table") return false;
+  if (ref.kind === "table") return true;
+  const row = block.rows[ref.rowIndex];
+  if (!row) return false;
+  if (ref.kind === "row") return true;
+  return row.cells[ref.cellIndex] !== undefined;
+}
+
 /**
  * Walk the canonical document and resolve a derived paragraph-like
  * scopeId to its range anchor. Returns `null` when no paragraph /
@@ -79,11 +120,11 @@ export function resolveDerivedScopeAnchorFromCanonical(
   scopeId: string,
   assoc: { readonly start: -1 | 1; readonly end: -1 | 1 } = { start: 1, end: -1 },
 ): EditorAnchorProjection | null {
-  // Fast-reject: derived paragraph-like scopeIds are always
-  // `para:…` / `heading:…` / `li:…`. Anything else (`table:…`,
-  // `field:…`, comment / revision ids, arbitrary host strings) can't
-  // match in this pass.
+  const tableRef = parseTableFamilyScopeId(scopeId);
+  // Fast-reject: derived metadata targets are paragraph-like or table-family
+  // scopeIds. Field/review/comment ids need their own source identity.
   if (
+    !tableRef &&
     !scopeId.startsWith("para:") &&
     !scopeId.startsWith("heading:") &&
     !scopeId.startsWith("li:")
@@ -118,6 +159,19 @@ export function resolveDerivedScopeAnchorFromCanonical(
       };
     }
 
+    if (
+      tableRef &&
+      tableRef.blockIndex === index &&
+      tableRefExists(block, tableRef)
+    ) {
+      return {
+        kind: "range",
+        from: cursor,
+        to: cursor + thisBlockLength,
+        assoc,
+      };
+    }
+
     cursor += thisBlockLength;
     if (index < blocks.length - 1) cursor += 1;
   }

package/src/runtime/workflow/index.ts

@@ -24,3 +24,6 @@ export * from "./coordinator.ts";
 export * from "./visibility-policy.ts";
 export * from "./markup-mode-policy.ts";
 export * from "./scope-rail-composer.ts";
+export * from "./word-field-matrix-calibration.ts";
+export * from "./redline-posture-calibration.ts";
+export * from "./ai-issue-lifecycle.ts";

package/src/runtime/workflow/overlay-lane-types.ts

@@ -0,0 +1,58 @@
+import type { GeometryRect } from "../geometry/geometry-types.ts";
+
+export type WorkflowOverlayAnchorQuery =
+  | { kind: "block"; value: string }
+  | { kind: "scope"; value: string }
+  | { kind: "comment"; value: string }
+  | { kind: "revision"; value: string }
+  | { kind: "page"; value: number }
+  | { kind: "selection" };
+
+export type WorkflowOverlayLaneKind =
+  | "selection"
+  | "caret"
+  | "redlines"
+  | "field-scopes"
+  | "broad-scopes"
+  | "comments"
+  | "issues"
+  | "tables"
+  | "objects"
+  | "search"
+  | "presence";
+
+export type WorkflowOverlayLaneStatus =
+  | "resolved"
+  | "requires-rehydration"
+  | "unavailable";
+
+export type WorkflowOverlayLaneSource =
+  | "geometry"
+  | "workflow"
+  | "search"
+  | "awareness"
+  | "controller"
+  | "unavailable";
+
+export interface WorkflowOverlayLaneEntry {
+  readonly id: string;
+  readonly status: WorkflowOverlayLaneStatus;
+  readonly anchor?: WorkflowOverlayAnchorQuery;
+  readonly rects?: readonly GeometryRect[];
+  readonly reason?: string;
+  /**
+   * Lane-specific plain payload. Examples: peer identity for presence,
+   * issue severity, search rank, table/object classification. Kept plain
+   * so non-React consumers and debug runners can serialize snapshots.
+   */
+  readonly data?: Readonly<Record<string, unknown>>;
+}
+
+export interface WorkflowOverlayLaneSnapshot {
+  readonly kind: WorkflowOverlayLaneKind;
+  readonly status: WorkflowOverlayLaneStatus;
+  readonly entries: readonly WorkflowOverlayLaneEntry[];
+  readonly revision: number;
+  readonly source: WorkflowOverlayLaneSource;
+  readonly reason?: string;
+}

package/src/runtime/workflow/overlay-lanes.ts

@@ -1,5 +1,6 @@
 import type {
   CommentSidebarSnapshot,
+  OverlayKind,
   SuggestionsSnapshot,
   TrackedChangesSnapshot,
   WorkflowMarkupSnapshot,
@@ -7,16 +8,44 @@ import type {
 } from "../../api/public-types.ts";
 import { ISSUE_METADATA_ID } from "../../api/public-types.ts";
 import type {
-  UiOverlayLaneEntry,
-  UiOverlayLaneKind,
-  UiOverlayLaneSnapshot,
-  UiOverlayLaneStatus,
-} from "../../api/v3/ui/index.ts";
+  WorkflowOverlayLaneEntry,
+  WorkflowOverlayLaneKind,
+  WorkflowOverlayLaneSnapshot,
+  WorkflowOverlayLaneStatus,
+} from "./overlay-lane-types.ts";
 
 export type WorkflowReviewOverlayLaneKind = Extract<
-  UiOverlayLaneKind,
+  WorkflowOverlayLaneKind,
   "redlines" | "comments" | "issues" | "field-scopes" | "broad-scopes" | "presence"
 >;
+export type WorkflowReviewOverlayLaneSnapshot = WorkflowOverlayLaneSnapshot;
+export type WorkflowReviewOverlayLaneListener = (
+  snapshot: WorkflowReviewOverlayLaneSnapshot,
+) => void;
+export type WorkflowReviewOverlayLaneRefreshEvent = {
+  readonly type:
+    | "ready"
+    | "comment_added"
+    | "comment_resolved"
+    | "comments_changed"
+    | "change_authored"
+    | "change_accepted"
+    | "change_rejected"
+    | "suggestion_authored"
+    | "suggestion_updated"
+    | "workflow_metadata_changed"
+    | "workflow_overlay_changed"
+    | "workflow_active_work_item_changed"
+    | "workflow_shared_state_changed"
+    | "workflow_visibility_policy_changed"
+    | "workflow_markup_mode_policy_changed"
+    | "toc_auto_refreshed"
+    | "warning_added"
+    | "warning_cleared"
+    | "error"
+    | string;
+  readonly kind?: unknown;
+};
 
 export interface WorkflowReviewOverlayLaneInput {
   readonly comments?: CommentSidebarSnapshot;
@@ -38,7 +67,7 @@ export interface WorkflowReviewOverlayLaneInput {
 export function projectWorkflowReviewOverlayLane(
   kind: WorkflowReviewOverlayLaneKind,
   input: WorkflowReviewOverlayLaneInput,
-): UiOverlayLaneSnapshot {
+): WorkflowOverlayLaneSnapshot {
   if (kind === "presence") {
     return {
       kind,
@@ -60,10 +89,94 @@ export function projectWorkflowReviewOverlayLane(
   };
 }
 
+export function shouldRefreshWorkflowReviewOverlayLane(
+  kind: WorkflowReviewOverlayLaneKind,
+  event: WorkflowReviewOverlayLaneRefreshEvent,
+): boolean {
+  if (kind === "presence") return false;
+  switch (event.type) {
+    case "ready":
+      return true;
+    case "comment_added":
+    case "comment_resolved":
+    case "comments_changed":
+      return kind === "comments";
+    case "change_authored":
+    case "change_accepted":
+    case "change_rejected":
+    case "suggestion_authored":
+    case "suggestion_updated":
+      return kind === "redlines";
+    case "workflow_metadata_changed":
+      return kind === "issues" || kind === "broad-scopes";
+    case "workflow_overlay_changed":
+    case "workflow_active_work_item_changed":
+    case "workflow_shared_state_changed":
+      return kind === "issues" || kind === "broad-scopes";
+    case "workflow_visibility_policy_changed":
+      return shouldRefreshForVisibilityPolicy(
+        kind,
+        isOverlayKind(event.kind) ? event.kind : undefined,
+      );
+    case "workflow_markup_mode_policy_changed":
+      return kind === "redlines";
+    case "toc_auto_refreshed":
+    case "warning_added":
+    case "warning_cleared":
+    case "error":
+      return kind === "field-scopes";
+    default:
+      return false;
+  }
+}
+
+export function areWorkflowReviewOverlayLaneSnapshotsEqual(
+  left: WorkflowReviewOverlayLaneSnapshot,
+  right: WorkflowReviewOverlayLaneSnapshot,
+): boolean {
+  return (
+    left.kind === right.kind &&
+    left.status === right.status &&
+    left.source === right.source &&
+    left.reason === right.reason &&
+    entriesEqual(left.entries, right.entries)
+  );
+}
+
+function isOverlayKind(value: unknown): value is OverlayKind {
+  return (
+    value === "scope-rail" ||
+    value === "comments" ||
+    value === "tracked-changes" ||
+    value === "suggestions" ||
+    value === "debug-panel" ||
+    value === "presence"
+  );
+}
+
+function shouldRefreshForVisibilityPolicy(
+  kind: Exclude<WorkflowReviewOverlayLaneKind, "presence">,
+  overlayKind: OverlayKind | undefined,
+): boolean {
+  switch (overlayKind) {
+    case "comments":
+      return kind === "comments";
+    case "tracked-changes":
+    case "suggestions":
+      return kind === "redlines";
+    case "scope-rail":
+      return kind === "broad-scopes";
+    case "presence":
+    case "debug-panel":
+    case undefined:
+      return false;
+  }
+}
+
 function projectEntries(
   kind: Exclude<WorkflowReviewOverlayLaneKind, "presence">,
   input: WorkflowReviewOverlayLaneInput,
-): UiOverlayLaneEntry[] {
+): WorkflowOverlayLaneEntry[] {
   switch (kind) {
     case "comments":
       return (input.comments?.threads ?? []).map((thread) => ({
@@ -165,7 +278,7 @@ function projectEntries(
   }
 }
 
-function projectIssueEntries(input: WorkflowReviewOverlayLaneInput): UiOverlayLaneEntry[] {
+function projectIssueEntries(input: WorkflowReviewOverlayLaneInput): WorkflowOverlayLaneEntry[] {
   const suggestionGroupsByIssueId = new Map<string, string[]>();
   for (const group of input.suggestions?.groups ?? []) {
     if (!group.issueId) continue;
@@ -207,12 +320,57 @@ function projectIssueEntries(input: WorkflowReviewOverlayLaneInput): UiOverlayLa
     });
 }
 
-function summarizeStatus(entries: readonly UiOverlayLaneEntry[]): UiOverlayLaneStatus {
+function summarizeStatus(entries: readonly WorkflowOverlayLaneEntry[]): WorkflowOverlayLaneStatus {
   return entries.some((entry) => entry.status === "requires-rehydration")
     ? "requires-rehydration"
     : "resolved";
 }
 
+function entriesEqual(
+  left: readonly WorkflowOverlayLaneEntry[],
+  right: readonly WorkflowOverlayLaneEntry[],
+): boolean {
+  if (left.length !== right.length) return false;
+  for (let index = 0; index < left.length; index += 1) {
+    const leftEntry = left[index];
+    const rightEntry = right[index];
+    if (!leftEntry || !rightEntry) return false;
+    if (
+      leftEntry.id !== rightEntry.id ||
+      leftEntry.status !== rightEntry.status ||
+      leftEntry.reason !== rightEntry.reason ||
+      !jsonValueEqual(leftEntry.anchor, rightEntry.anchor) ||
+      !jsonValueEqual(leftEntry.rects, rightEntry.rects) ||
+      !jsonValueEqual(leftEntry.data, rightEntry.data)
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function jsonValueEqual(left: unknown, right: unknown): boolean {
+  return stableJson(left) === stableJson(right);
+}
+
+function stableJson(value: unknown): string {
+  return JSON.stringify(sortJsonValue(value));
+}
+
+function sortJsonValue(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(sortJsonValue);
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  const sorted: Record<string, unknown> = {};
+  for (const key of Object.keys(value).sort()) {
+    sorted[key] = sortJsonValue(value[key]);
+  }
+  return sorted;
+}
+
 function compactData(input: Record<string, unknown>): Readonly<Record<string, unknown>> {
   const output: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(input)) {

package/src/runtime/workflow/overlay-store.ts

@@ -22,8 +22,8 @@
  *
  * What it does NOT own (by design — those belong to the coordinator):
  *   - interaction-guard / workflow-scope / workflow-markup snapshot
- *     caches (require runtime-scope deps like revisionToken, render
- *     snapshot, selection).
+ *     caches (require runtime-scope deps like render snapshot,
+ *     selection, protection, and active story).
  *   - blocked-reason composition + scope-matching heuristics (require
  *     protection snapshot + viewState.documentMode).
  *   - rail / card composition (requires page graph + render frame).

package/src/runtime/workflow/redline-posture-calibration.ts

@@ -0,0 +1,257 @@
+export type WorkflowRedlinePosture = "all-markup" | "final" | "original" | "unknown";
+
+export interface WorkflowRedlineDatasetDocumentLike {
+  readonly docId: string;
+  readonly status: string;
+  readonly pages: number;
+  readonly revisions: number;
+  readonly comments: number;
+  readonly fields?: number;
+  readonly uiaLines?: number;
+  readonly datasetPath?: string;
+}
+
+export interface WorkflowRedlineDatasetManifestLike {
+  readonly schemaVersion: string;
+  readonly sourceRun: string;
+  readonly captureMatrix?: {
+    readonly markupModes?: readonly string[];
+  };
+  readonly targetedWord?: {
+    readonly version?: string;
+    readonly build?: string;
+    readonly activePrinter?: string;
+  };
+  readonly documents: readonly WorkflowRedlineDatasetDocumentLike[];
+}
+
+export interface WorkflowRedlineFieldIdentityTotalsLike {
+  readonly wordFields: number;
+  readonly joined: number;
+  readonly missingSourceField: number;
+  readonly missingCanonicalField: number;
+  readonly missingRuntimeRegion: number;
+  readonly actionableL04: number;
+}
+
+export type WorkflowRedlinePostureFactId =
+  | "all-markup-review-posture"
+  | "revision-comment-counts"
+  | "clean-all-markup-measurement-handoff"
+  | "redline-field-identity-posture";
+
+export type WorkflowRedlinePostureRepresentation =
+  | "durable-workflow-review-posture"
+  | "measurement-handoff"
+  | "field-region-posture-handoff"
+  | "blocked-until-identity-join";
+
+export interface WorkflowRedlinePostureFact {
+  readonly factId: WorkflowRedlinePostureFactId;
+  readonly representation: WorkflowRedlinePostureRepresentation;
+  readonly posture: WorkflowRedlinePosture;
+  readonly sourceRun: string;
+  readonly l06Surfaces: readonly string[];
+  readonly downstreamRoutes: readonly string[];
+  readonly evidence: Readonly<Record<string, number | string | boolean>>;
+  readonly note: string;
+}
+
+export interface WorkflowRedlinePostureCalibration {
+  readonly schemaVersion: "l06-redline-posture-calibration/v0";
+  readonly facts: readonly WorkflowRedlinePostureFact[];
+  readonly summary: {
+    readonly documentCount: number;
+    readonly availableDocumentCount: number;
+    readonly pageCount: number;
+    readonly revisionCount: number;
+    readonly commentCount: number;
+    readonly fieldCount: number;
+    readonly uiaLineCount: number;
+    readonly posture: WorkflowRedlinePosture;
+    readonly downstreamRouteCount: number;
+    readonly l04ActionableFieldRows: number;
+    readonly ownsGeometry: false;
+    readonly ownsVisualPaint: false;
+  };
+}
+
+export interface WorkflowRedlinePostureCalibrationInput {
+  readonly manifest: WorkflowRedlineDatasetManifestLike;
+  readonly fieldIdentityTotals?: WorkflowRedlineFieldIdentityTotalsLike;
+}
+
+interface WorkflowRedlinePostureTotals {
+  readonly documentCount: number;
+  readonly availableDocumentCount: number;
+  readonly pageCount: number;
+  readonly revisionCount: number;
+  readonly commentCount: number;
+  readonly fieldCount: number;
+  readonly uiaLineCount: number;
+}
+
+export function calibrateWorkflowReviewRedlinePosture(
+  input: WorkflowRedlinePostureCalibrationInput,
+): WorkflowRedlinePostureCalibration {
+  const documents = input.manifest.documents;
+  const availableDocuments = documents.filter((document) => document.status === "available");
+  const posture = resolvePosture(input.manifest.captureMatrix?.markupModes);
+  const totals = {
+    documentCount: documents.length,
+    availableDocumentCount: availableDocuments.length,
+    pageCount: sum(availableDocuments, (document) => document.pages),
+    revisionCount: sum(availableDocuments, (document) => document.revisions),
+    commentCount: sum(availableDocuments, (document) => document.comments),
+    fieldCount: sum(availableDocuments, (document) => document.fields ?? 0),
+    uiaLineCount: sum(availableDocuments, (document) => document.uiaLines ?? 0),
+  };
+
+  const facts = [
+    buildAllMarkupPostureFact(input.manifest, posture, totals),
+    buildReviewCountFact(input.manifest, posture, totals),
+    buildMeasurementHandoffFact(input.manifest, posture, totals),
+    buildFieldIdentityFact(input.manifest, posture, totals, input.fieldIdentityTotals),
+  ];
+
+  return {
+    schemaVersion: "l06-redline-posture-calibration/v0",
+    facts,
+    summary: {
+      ...totals,
+      posture,
+      downstreamRouteCount: new Set(facts.flatMap((fact) => fact.downstreamRoutes)).size,
+      l04ActionableFieldRows: input.fieldIdentityTotals?.actionableL04 ?? 0,
+      ownsGeometry: false,
+      ownsVisualPaint: false,
+    },
+  };
+}
+
+function buildAllMarkupPostureFact(
+  manifest: WorkflowRedlineDatasetManifestLike,
+  posture: WorkflowRedlinePosture,
+  totals: WorkflowRedlinePostureTotals,
+): WorkflowRedlinePostureFact {
+  return {
+    factId: "all-markup-review-posture",
+    representation: "durable-workflow-review-posture",
+    posture,
+    sourceRun: manifest.sourceRun,
+    l06Surfaces: [
+      "WorkflowMarkupModePolicy",
+      "WorkflowMarkupSnapshot.revisions",
+      "TrackedChangesSnapshot.revisions",
+    ],
+    downstreamRoutes: ["L04 redline measurement posture", "L11 redline overlay paint"],
+    evidence: {
+      documents: totals.documentCount,
+      availableDocuments: totals.availableDocumentCount,
+      wordVersion: manifest.targetedWord?.version ?? "unknown",
+      wordBuild: manifest.targetedWord?.build ?? "unknown",
+    },
+    note:
+      "The redline Word JSON dataset is captured in all-markup posture; L06 names that durable review posture before layout or paint consume it.",
+  };
+}
+
+function buildReviewCountFact(
+  manifest: WorkflowRedlineDatasetManifestLike,
+  posture: WorkflowRedlinePosture,
+  totals: WorkflowRedlinePostureTotals,
+): WorkflowRedlinePostureFact {
+  return {
+    factId: "revision-comment-counts",
+    representation: "durable-workflow-review-posture",
+    posture,
+    sourceRun: manifest.sourceRun,
+    l06Surfaces: [
+      "WorkflowMarkupSnapshot.revisions",
+      "WorkflowMarkupSnapshot.comments",
+      "TrackedChangesSnapshot.revisions",
+      "CommentSidebarSnapshot.threads",
+    ],
+    downstreamRoutes: ["L11 review/comment lane visibility", "L08 comment/revision scope posture"],
+    evidence: {
+      revisions: totals.revisionCount,
+      comments: totals.commentCount,
+      documentsWithReviewData: totals.availableDocumentCount,
+    },
+    note:
+      "Revision and comment totals are L06 review-store facts; geometry and balloon placement stay with downstream consumers.",
+  };
+}
+
+function buildMeasurementHandoffFact(
+  manifest: WorkflowRedlineDatasetManifestLike,
+  posture: WorkflowRedlinePosture,
+  totals: WorkflowRedlinePostureTotals,
+): WorkflowRedlinePostureFact {
+  return {
+    factId: "clean-all-markup-measurement-handoff",
+    representation: "measurement-handoff",
+    posture,
+    sourceRun: manifest.sourceRun,
+    l06Surfaces: ["EffectiveLayoutFormatting.revisionPosture", "WorkflowMarkupModePolicy"],
+    downstreamRoutes: ["L04 clean-vs-all-markup page/frame delta", "L11 render-word assertion planning"],
+    evidence: {
+      pagesInAllMarkupPosture: totals.pageCount,
+      uiaLinesInAllMarkupPosture: totals.uiaLineCount,
+      ownsGeometry: false,
+    },
+    note:
+      "L06 names the measurement-affecting review posture; L04 owns page/frame deltas and L11 owns visual assertion planning.",
+  };
+}
+
+function buildFieldIdentityFact(
+  manifest: WorkflowRedlineDatasetManifestLike,
+  posture: WorkflowRedlinePosture,
+  totals: WorkflowRedlinePostureTotals,
+  fieldIdentityTotals: WorkflowRedlineFieldIdentityTotalsLike | undefined,
+): WorkflowRedlinePostureFact {
+  const actionableRows = fieldIdentityTotals?.actionableL04 ?? 0;
+  return {
+    factId: "redline-field-identity-posture",
+    representation: actionableRows > 0 ? "field-region-posture-handoff" : "blocked-until-identity-join",
+    posture,
+    sourceRun: manifest.sourceRun,
+    l06Surfaces: ["WorkflowMarkupModePolicy", "WorkflowMarkupSnapshot.fields"],
+    downstreamRoutes: [
+      "L01 source field identity",
+      "L02 canonical field identity",
+      "L04 redline field-region measurement",
+    ],
+    evidence: {
+      redlineWordFields: fieldIdentityTotals?.wordFields ?? totals.fieldCount,
+      sourceJoinedRows: fieldIdentityTotals?.joined ?? 0,
+      missingSourceField: fieldIdentityTotals?.missingSourceField ?? 0,
+      missingCanonicalField: fieldIdentityTotals?.missingCanonicalField ?? 0,
+      missingRuntimeRegion: fieldIdentityTotals?.missingRuntimeRegion ?? 0,
+      actionableL04: actionableRows,
+    },
+    note:
+      actionableRows > 0
+        ? "L06 review posture is named and the field rows may proceed to L04 with identity joins present."
+        : "L06 review posture is named as all-markup, but redline field-region rows remain blocked on source/canonical/runtime identity joins.",
+  };
+}
+
+function resolvePosture(markupModes: readonly string[] | undefined): WorkflowRedlinePosture {
+  if (!markupModes || markupModes.length !== 1) return "unknown";
+  switch (markupModes[0]) {
+    case "all":
+    case "all-markup":
+      return "all-markup";
+    case "final":
+      return "final";
+    case "original":
+      return "original";
+    default:
+      return "unknown";
+  }
+}
+
+function sum<T>(items: readonly T[], selector: (item: T) => number): number {
+  return items.reduce((total, item) => total + selector(item), 0);
+}