@beyondwork/docx-react-component 1.0.106 → 1.0.109

package/src/runtime/scopes/layout-evidence.ts

@@ -0,0 +1,374 @@
+/**
+ * Scope layout evidence projection.
+ *
+ * Layer 08 only consumes layout evidence supplied by lower layers. When the
+ * seam is absent or cold, the bundle reports that explicitly instead of
+ * deriving page slices or continuation state from canonical content.
+ */
+
+import type {
+  ScopeLayoutContinuationEvidence,
+  ScopeLayoutEvidence,
+  ScopeTableFrameEvidence,
+  ScopeTableFramePageEvidence,
+} from "./semantic-scope-types.ts";
+
+export interface ScopeLayoutEvidenceEntry {
+  readonly status?: ScopeLayoutEvidence["status"];
+  readonly completeness?: ScopeLayoutEvidence["completeness"];
+  readonly reason?: string;
+  readonly pageSliceIds?: readonly string[];
+  readonly layoutObjectIds?: readonly string[];
+  readonly continuationState?: ScopeLayoutContinuationEvidence;
+  readonly divergenceIds?: readonly string[];
+  readonly tableFrame?: ScopeTableFrameEvidence;
+}
+
+export interface ScopeLayoutEvidenceProvider {
+  getScopeLayoutEvidence(scopeId: string): ScopeLayoutEvidenceEntry | null;
+}
+
+export interface ScopeRuntimeLayoutFragment {
+  readonly fragmentId: string;
+  readonly blockId: string;
+  readonly pageId: string;
+  readonly pageIndex: number;
+  readonly kind?: "whole" | "paragraph-slice" | "table-slice";
+  readonly tableRowRange?: {
+    readonly from: number;
+    readonly to: number;
+    readonly totalRows: number;
+  };
+  readonly continuation?: {
+    readonly kind: string;
+    readonly continuesFromPreviousPage?: boolean;
+    readonly continuesToNextPage?: boolean;
+    readonly repeatedHeaderRowIndexes?: readonly number[];
+    readonly splitRowCarry?: readonly {
+      readonly rowIndex: number;
+      readonly continuesFromPreviousPage: boolean;
+      readonly continuesToNextPage: boolean;
+    }[];
+    readonly verticalMergeCarry?: readonly {
+      readonly columnIndex: number;
+      readonly restartRowIndex: number;
+    }[];
+  };
+  readonly layoutObject?: {
+    readonly objectId?: string;
+  };
+}
+
+export interface ScopeRuntimeLayoutEvidenceSource {
+  getPageCount(): number;
+  getFragmentsForPage(pageIndex: number): readonly ScopeRuntimeLayoutFragment[];
+}
+
+export interface RuntimeTableFrameLayoutEvidenceOptions {
+  readonly layout: ScopeRuntimeLayoutEvidenceSource;
+  readonly tableBlockIdsByBlockIndex?: ReadonlyMap<number, string>;
+}
+
+export interface ScopeRuntimeRenderSnapshotLike {
+  readonly surface?: {
+    readonly blocks?: readonly {
+      readonly kind?: string;
+      readonly blockId?: string;
+    }[];
+  };
+}
+
+function freezeList<T>(values: readonly T[] | undefined): readonly T[] | undefined {
+  return values ? Object.freeze([...values]) : undefined;
+}
+
+function unique<T>(values: readonly T[]): readonly T[] {
+  return Object.freeze([...new Set(values)]);
+}
+
+function parseTableFamilyScopeId(scopeId: string):
+  | { readonly scopeKind: "table"; readonly blockIndex: number }
+  | { readonly scopeKind: "table-row"; readonly blockIndex: number; readonly rowIndex: number }
+  | {
+      readonly scopeKind: "table-cell";
+      readonly blockIndex: number;
+      readonly rowIndex: number;
+      readonly cellIndex: number;
+    }
+  | null {
+  const table = /^table:(\d+)$/.exec(scopeId);
+  if (table) return { scopeKind: "table", blockIndex: Number(table[1]) };
+  const row = /^row:(\d+):(\d+)$/.exec(scopeId);
+  if (row) {
+    return {
+      scopeKind: "table-row",
+      blockIndex: Number(row[1]),
+      rowIndex: Number(row[2]),
+    };
+  }
+  const cell = /^cell:(\d+):(\d+):(\d+)$/.exec(scopeId);
+  if (cell) {
+    return {
+      scopeKind: "table-cell",
+      blockIndex: Number(cell[1]),
+      rowIndex: Number(cell[2]),
+      cellIndex: Number(cell[3]),
+    };
+  }
+  return null;
+}
+
+function candidateTableBlockIds(
+  blockIndex: number,
+  mapped?: ReadonlyMap<number, string>,
+): readonly string[] {
+  const ids: string[] = [];
+  const mappedId = mapped?.get(blockIndex);
+  if (mappedId) ids.push(mappedId);
+  ids.push(`table-${blockIndex}`, `table:${blockIndex}`, `block-${blockIndex}`);
+  return unique(ids);
+}
+
+function rowInFragment(
+  fragment: ScopeRuntimeLayoutFragment,
+  rowIndex: number,
+): boolean {
+  const range = fragment.tableRowRange;
+  if (range && rowIndex >= range.from && rowIndex < range.to) return true;
+  return fragment.continuation?.repeatedHeaderRowIndexes?.includes(rowIndex) === true;
+}
+
+function fragmentMatchesScope(
+  fragment: ScopeRuntimeLayoutFragment,
+  parsed: NonNullable<ReturnType<typeof parseTableFamilyScopeId>>,
+): boolean {
+  if (parsed.scopeKind === "table") return true;
+  return rowInFragment(fragment, parsed.rowIndex);
+}
+
+function collectTableFragments(
+  layout: ScopeRuntimeLayoutEvidenceSource,
+  blockIds: readonly string[],
+  parsed: NonNullable<ReturnType<typeof parseTableFamilyScopeId>>,
+): readonly ScopeRuntimeLayoutFragment[] {
+  const matches: ScopeRuntimeLayoutFragment[] = [];
+  const blockIdSet = new Set(blockIds);
+  for (let pageIndex = 0; pageIndex < layout.getPageCount(); pageIndex += 1) {
+    for (const fragment of layout.getFragmentsForPage(pageIndex)) {
+      if (!blockIdSet.has(fragment.blockId)) continue;
+      if (fragment.kind !== undefined && fragment.kind !== "table-slice" && fragment.kind !== "whole") {
+        continue;
+      }
+      if (!fragmentMatchesScope(fragment, parsed)) continue;
+      matches.push(fragment);
+    }
+  }
+  return Object.freeze(matches);
+}
+
+function projectTableFramePage(
+  fragment: ScopeRuntimeLayoutFragment,
+): ScopeTableFramePageEvidence {
+  const repeated = fragment.continuation?.repeatedHeaderRowIndexes;
+  const splitRowCarry = fragment.continuation?.splitRowCarry;
+  const carry = fragment.continuation?.verticalMergeCarry;
+  return {
+    pageId: fragment.pageId,
+    pageIndex: fragment.pageIndex,
+    fragmentId: fragment.fragmentId,
+    ...(fragment.tableRowRange ? { rowRange: { ...fragment.tableRowRange } } : {}),
+    ...(fragment.continuation?.continuesFromPreviousPage !== undefined
+      ? { continuesFromPreviousPage: fragment.continuation.continuesFromPreviousPage }
+      : {}),
+    ...(fragment.continuation?.continuesToNextPage !== undefined
+      ? { continuesToNextPage: fragment.continuation.continuesToNextPage }
+      : {}),
+    ...(repeated ? { repeatedHeaderRowIndexes: unique(repeated) } : {}),
+    ...(splitRowCarry ? { splitRowCarry: Object.freeze(splitRowCarry.map((item) => ({ ...item }))) } : {}),
+    ...(carry ? { verticalMergeCarry: Object.freeze(carry.map((item) => ({ ...item }))) } : {}),
+  };
+}
+
+function projectTableFrame(
+  blockId: string,
+  parsed: NonNullable<ReturnType<typeof parseTableFamilyScopeId>>,
+  fragments: readonly ScopeRuntimeLayoutFragment[],
+): ScopeTableFrameEvidence {
+  const pageIds = unique(fragments.map((fragment) => fragment.pageId));
+  const pageSliceIds = unique(fragments.map((fragment) => fragment.fragmentId));
+  const layoutObjectIds = unique(
+    fragments
+      .map((fragment) => fragment.layoutObject?.objectId)
+      .filter((objectId): objectId is string => typeof objectId === "string" && objectId.length > 0),
+  );
+  const rowRangesByPage = Object.freeze(fragments.map(projectTableFramePage));
+  const repeatedHeaderRowIndexes = unique(
+    fragments.flatMap((fragment) => fragment.continuation?.repeatedHeaderRowIndexes ?? []),
+  );
+  const verticalMergeCarry = Object.freeze(
+    fragments
+      .flatMap((fragment) => fragment.continuation?.verticalMergeCarry ?? [])
+      .map((item) => ({ ...item })),
+  );
+  const splitRowCarry = Object.freeze(
+    fragments
+      .flatMap((fragment) => fragment.continuation?.splitRowCarry ?? [])
+      .map((item) => ({ ...item })),
+  );
+  return {
+    source: "runtime.layout.table-frame-continuation",
+    blockId,
+    scopeKind: parsed.scopeKind,
+    ...(parsed.scopeKind === "table-row" || parsed.scopeKind === "table-cell"
+      ? { rowIndex: parsed.rowIndex }
+      : {}),
+    ...(parsed.scopeKind === "table-cell" ? { cellIndex: parsed.cellIndex } : {}),
+    ...(pageIds.length > 0 ? { pageIds } : {}),
+    ...(pageSliceIds.length > 0 ? { pageSliceIds } : {}),
+    ...(layoutObjectIds.length > 0 ? { layoutObjectIds } : {}),
+    ...(rowRangesByPage.length > 0 ? { rowRangesByPage } : {}),
+    ...(repeatedHeaderRowIndexes.length > 0 ? { repeatedHeaderRowIndexes } : {}),
+    ...(splitRowCarry.length > 0 ? { splitRowCarry } : {}),
+    ...(verticalMergeCarry.length > 0 ? { verticalMergeCarry } : {}),
+  };
+}
+
+function continuationFromTableFrame(
+  fragments: readonly ScopeRuntimeLayoutFragment[],
+): ScopeLayoutContinuationEvidence {
+  const pageIds = unique(fragments.map((fragment) => fragment.pageId));
+  return {
+    ...(pageIds.length > 0 ? { pageIds } : {}),
+    pageCount: pageIds.length,
+    crossesPageBoundary: pageIds.length > 1,
+    continuedFromPreviousPage: fragments.some(
+      (fragment) => fragment.continuation?.continuesFromPreviousPage === true,
+    ),
+    continuesToNextPage: fragments.some(
+      (fragment) => fragment.continuation?.continuesToNextPage === true,
+    ),
+  };
+}
+
+export function createRuntimeTableFrameLayoutEvidenceProvider(
+  options: RuntimeTableFrameLayoutEvidenceOptions,
+): ScopeLayoutEvidenceProvider {
+  return {
+    getScopeLayoutEvidence(scopeId) {
+      const parsed = parseTableFamilyScopeId(scopeId);
+      if (!parsed) return null;
+
+      const blockIds = candidateTableBlockIds(
+        parsed.blockIndex,
+        options.tableBlockIdsByBlockIndex,
+      );
+      const fragments = collectTableFragments(options.layout, blockIds, parsed);
+      if (fragments.length === 0) return null;
+
+      const blockId = fragments[0]?.blockId ?? blockIds[0] ?? `table-${parsed.blockIndex}`;
+      const tableFrame = projectTableFrame(blockId, parsed, fragments);
+      const pageSliceIds = tableFrame.pageSliceIds;
+      const layoutObjectIds = tableFrame.layoutObjectIds;
+      const cellScoped = parsed.scopeKind === "table-cell";
+      return {
+        status: "available",
+        completeness: cellScoped ? "partial" : "complete",
+        reason: cellScoped
+          ? "l04-table-frame-row-level-evidence"
+          : "l04-table-frame-continuation",
+        ...(pageSliceIds ? { pageSliceIds } : {}),
+        ...(layoutObjectIds ? { layoutObjectIds } : {}),
+        continuationState: continuationFromTableFrame(fragments),
+        tableFrame,
+      };
+    },
+  };
+}
+
+export function collectTopLevelTableBlockIdsFromRenderSnapshot(
+  snapshot: ScopeRuntimeRenderSnapshotLike | null | undefined,
+): ReadonlyMap<number, string> {
+  const out = new Map<number, string>();
+  const blocks = snapshot?.surface?.blocks ?? [];
+  blocks.forEach((block, blockIndex) => {
+    if (block.kind === "table" && typeof block.blockId === "string") {
+      out.set(blockIndex, block.blockId);
+    }
+  });
+  return out;
+}
+
+function cloneTableFrame(
+  tableFrame: ScopeTableFrameEvidence,
+): ScopeTableFrameEvidence {
+  return {
+    ...tableFrame,
+    ...(tableFrame.pageIds ? { pageIds: freezeList(tableFrame.pageIds) } : {}),
+    ...(tableFrame.pageSliceIds ? { pageSliceIds: freezeList(tableFrame.pageSliceIds) } : {}),
+    ...(tableFrame.layoutObjectIds ? { layoutObjectIds: freezeList(tableFrame.layoutObjectIds) } : {}),
+    ...(tableFrame.rowRangesByPage
+      ? {
+          rowRangesByPage: Object.freeze(
+            tableFrame.rowRangesByPage.map((row) => ({
+              ...row,
+              ...(row.rowRange ? { rowRange: { ...row.rowRange } } : {}),
+              ...(row.repeatedHeaderRowIndexes
+                ? { repeatedHeaderRowIndexes: freezeList(row.repeatedHeaderRowIndexes) }
+                : {}),
+              ...(row.splitRowCarry
+                ? { splitRowCarry: Object.freeze(row.splitRowCarry.map((item) => ({ ...item }))) }
+                : {}),
+              ...(row.verticalMergeCarry
+                ? { verticalMergeCarry: Object.freeze(row.verticalMergeCarry.map((item) => ({ ...item }))) }
+                : {}),
+            })),
+          ),
+        }
+      : {}),
+    ...(tableFrame.repeatedHeaderRowIndexes
+      ? { repeatedHeaderRowIndexes: freezeList(tableFrame.repeatedHeaderRowIndexes) }
+      : {}),
+    ...(tableFrame.splitRowCarry
+      ? { splitRowCarry: Object.freeze(tableFrame.splitRowCarry.map((item) => ({ ...item }))) }
+      : {}),
+    ...(tableFrame.verticalMergeCarry
+      ? { verticalMergeCarry: Object.freeze(tableFrame.verticalMergeCarry.map((item) => ({ ...item }))) }
+      : {}),
+  };
+}
+
+export function deriveScopeLayoutEvidence(
+  scopeId: string,
+  provider?: ScopeLayoutEvidenceProvider,
+): ScopeLayoutEvidence {
+  if (!provider) {
+    return {
+      status: "unavailable",
+      completeness: "unavailable",
+      reason: "layout-evidence-provider-unavailable",
+    };
+  }
+
+  const entry = provider.getScopeLayoutEvidence(scopeId);
+  if (!entry) {
+    return {
+      status: "requires-rehydration",
+      completeness: "requires-rehydration",
+      reason: "scope-layout-evidence-unavailable",
+    };
+  }
+
+  const status = entry.status ?? "available";
+  return {
+    status,
+    completeness: entry.completeness ?? (status === "available" ? "complete" : status),
+    ...(entry.reason ? { reason: entry.reason } : {}),
+    ...(entry.pageSliceIds ? { pageSliceIds: freezeList(entry.pageSliceIds) } : {}),
+    ...(entry.layoutObjectIds ? { layoutObjectIds: freezeList(entry.layoutObjectIds) } : {}),
+    ...(entry.continuationState
+      ? { continuationState: { ...entry.continuationState } }
+      : {}),
+    ...(entry.divergenceIds ? { divergenceIds: freezeList(entry.divergenceIds) } : {}),
+    ...(entry.tableFrame ? { tableFrame: cloneTableFrame(entry.tableFrame) } : {}),
+  };
+}

package/src/runtime/scopes/multi-paragraph-refusal.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared KI-014 refusal facts for marker-backed multi-paragraph scopes.
+ *
+ * These blockers are evidence only: they describe why broad replacement is
+ * still disabled and which facts must exist before L08 can safely lower it.
+ */
+
+export type MultiParagraphReplacementShape = "text" | "fragment" | "unknown";
+
+export const MULTI_PARAGRAPH_REPLACEMENT_REFUSAL =
+  "compile-refused:scope:multi-paragraph-replace-not-implemented";
+
+function shapeBlocker(shape: MultiParagraphReplacementShape): string {
+  switch (shape) {
+    case "text":
+      return "compile-refused:scope:multi-paragraph-text-replace-not-implemented";
+    case "fragment":
+      return "compile-refused:scope:multi-paragraph-fragment-replace-not-implemented";
+    default:
+      return "compile-refused:scope:multi-paragraph-replace-shape-not-implemented";
+  }
+}
+
+export function multiParagraphReplacementBlockers(
+  shape: MultiParagraphReplacementShape = "unknown",
+): readonly string[] {
+  return Object.freeze([
+    MULTI_PARAGRAPH_REPLACEMENT_REFUSAL,
+    shapeBlocker(shape),
+    "capability:scope:block-granular-replacement-lowering-required",
+    "capability:scope:provenance:marker-backed-required",
+    "capability:scope:layout-completeness-required",
+    "capability:scope:geometry-completeness-required",
+    "capability:scope:continuation-state-required",
+    "capability:scope:preservation-verdict-required",
+  ]);
+}

package/src/runtime/scopes/preservation-boundary.ts

@@ -2,7 +2,7 @@
  * Layer 08 — preservation-boundary helper (Slice 4 interim).
  *
  * Computes whether a scope's canonical range crosses any preserve-only
- * boundary that would be destroyed by a replace/split/insert operation.
+ * boundary that would be destroyed by a replacement operation.
  * Sources consulted:
  *
  *   - `document.preservation.opaqueFragments` — `OpaqueFragmentRecord[]`
@@ -29,6 +29,7 @@
 import type { CanonicalDocument } from "../../model/canonical-document.ts";
 import { findOpaqueFragmentsIntersectingRange } from "../../preservation/store.ts";
 
+import { findContentControlsIntersectingRange } from "./content-control-evidence.ts";
 import type { ScopePositionMap, ScopePositionRange } from "./position-map.ts";
 
 export interface PreservationVerdict {
@@ -69,6 +70,11 @@ export function computePreservationVerdict(
     );
   }
 
+  const contentControls = findContentControlsIntersectingRange(document, range);
+  for (const control of contentControls) {
+    reasons.push(`content-control:${control.evidenceId}`);
+  }
+
   if (positionMap) {
     for (const [scopeId, markerRange] of positionMap.markerScopes) {
       // A marker range strictly inside the target range would be

package/src/runtime/scopes/replacement/apply.ts

@@ -33,6 +33,10 @@ import { enumerateScopes } from "../enumerate-scopes.ts";
 import type { EnumeratedScope } from "../enumerate-scopes.ts";
 import { emitScopeActionAudit } from "../audit-bundle.ts";
 import { compileReplacement } from "./compile.ts";
+import {
+  MULTI_PARAGRAPH_REPLACEMENT_REFUSAL,
+  multiParagraphReplacementBlockers,
+} from "../multi-paragraph-refusal.ts";
 import type {
   ReplacementScope,
   RuntimeOperationPlan,
@@ -47,6 +51,7 @@ export interface ApplyScopeReplacementSink {
   readonly getInteractionGuardSnapshot: () => InteractionGuardSnapshot;
   readonly getCompatibilityReport: () => CompatibilityReport;
   readonly applyScopeReplacement: (plan: RuntimeOperationPlan) => void;
+  readonly verifyReadback?: boolean;
 }
 
 export interface ApplyScopeReplacementInputs {
@@ -80,19 +85,28 @@ export interface ApplyScopeReplacementResult {
 }
 
 function documentHash(doc: CanonicalDocumentEnvelope): string {
-  // Cheap structural hash — block-count + total text length. Good enough
-  // for the audit's "something changed" signal; later slices can swap in
-  // a canonical serializer-backed content hash.
-  const root = doc.content;
-  let textLength = 0;
-  for (const block of root.children) {
-    if (block.type === "paragraph") {
-      for (const child of block.children) {
-        if (child.type === "text") textLength += child.text.length;
-      }
-    }
+  // Structural content hash. This is intentionally stronger than length-only
+  // so same-length stale/no-op replacements do not report as successful edits.
+  return JSON.stringify(doc.content);
+}
+
+function compileScopeById(
+  document: CanonicalDocumentEnvelope,
+  overlay: WorkflowOverlay | undefined,
+  scopeId: string,
+): { readonly scope: SemanticScope; readonly entry: EnumeratedScope } | null {
+  const paragraphIndexByBlockIndex = buildParagraphIndexMap(document);
+  const enumerateInputs = overlay ? { overlay } : {};
+  for (const entry of enumerateScopes(document, enumerateInputs)) {
+    if (entry.handle.scopeId !== scopeId) continue;
+    const compiled = compileScope(entry, {
+      document,
+      ...(overlay ? { overlay } : {}),
+      paragraphIndexByBlockIndex,
+    });
+    if (compiled) return { scope: compiled, entry };
   }
-  return `blocks:${root.children.length}|text:${textLength}`;
+  return null;
 }
 
 export function applyScopeReplacement(
@@ -102,27 +116,18 @@ export function applyScopeReplacement(
   const docBefore = inputs.sink.getCanonicalDocument();
   const overlay = inputs.sink.getWorkflowOverlay() ?? undefined;
 
-  const paragraphIndexByBlockIndex = buildParagraphIndexMap(docBefore);
-  let resolvedScope: SemanticScope | null = null;
-  let resolvedEnumerated: EnumeratedScope | null = null;
-  const enumerateInputs = overlay ? { overlay } : {};
-  for (const entry of enumerateScopes(docBefore, enumerateInputs)) {
-    if (entry.handle.scopeId !== proposed.targetHandle.scopeId) continue;
-    const compiled = compileScope(entry, {
-      document: docBefore,
-      ...(overlay ? { overlay } : {}),
-      paragraphIndexByBlockIndex,
-    });
-    if (compiled) {
-      resolvedScope = compiled;
-      resolvedEnumerated = entry;
-      break;
-    }
-  }
+  const resolved = compileScopeById(
+    docBefore,
+    overlay,
+    proposed.targetHandle.scopeId,
+  );
+  const resolvedScope = resolved?.scope ?? null;
+  const resolvedEnumerated = resolved?.entry ?? null;
 
   if (!resolvedScope || !resolvedEnumerated) {
     const validation: ValidationResult = {
       safe: false,
+      posture: "hard-refusal",
       blockedReasons: Object.freeze([
         `scope-not-resolvable:${proposed.targetHandle.scopeId}`,
       ]),
@@ -207,15 +212,30 @@ export function applyScopeReplacement(
     // `blockers[0]` / `reason` see the actionable sub-reason directly
     // (rather than the bare `compile-refused:scope`). Grammar matches
     // §10 `compile-refused:<kind>:<sub-reason>` (74a45eaf, 2026-04-23).
-    const blocker =
+    const blockers =
       resolvedScope.kind === "scope"
-        ? "compile-refused:scope:multi-paragraph-replace-not-implemented"
+        ? multiParagraphReplacementBlockers(
+            proposed.proposedContent.kind === "structured" ? "fragment" : "text",
+          )
+        : paragraphLike &&
+            proposed.operation === "replace" &&
+            proposed.preserve?.opaqueFragments === true
+          ? [
+              `compile-refused:${resolvedScope.kind}:opaque-preserving-text-target-unavailable`,
+            ]
         : paragraphLike && proposed.operation !== "replace"
-          ? `compile-refused:${resolvedScope.kind}:operation-not-implemented:${proposed.operation}`
-          : `compile-refused:${resolvedScope.kind}`;
+          ? [
+              `compile-refused:${resolvedScope.kind}:operation-not-implemented:${proposed.operation}`,
+            ]
+          : [`compile-refused:${resolvedScope.kind}`];
+    const blocker =
+      resolvedScope.kind === "scope"
+        ? MULTI_PARAGRAPH_REPLACEMENT_REFUSAL
+        : blockers[0] ?? `compile-refused:${resolvedScope.kind}`;
     const refused: ValidationResult = {
       safe: false,
-      blockedReasons: Object.freeze([blocker]),
+      posture: "hard-refusal",
+      blockedReasons: Object.freeze([...blockers]),
       warnings: verdict.warnings,
     };
     // Coord-08 U5 — `reason` mirrors `blockers[0]` for symmetry. Agents
@@ -251,6 +271,49 @@ export function applyScopeReplacement(
 
   const docAfter = inputs.sink.getCanonicalDocument();
   const documentHashAfter = documentHash(docAfter);
+  const readback = compileScopeById(
+    docAfter,
+    inputs.sink.getWorkflowOverlay() ?? undefined,
+    proposed.targetHandle.scopeId,
+  );
+  const proposedText =
+    proposed.proposedContent.kind === "text"
+      ? proposed.proposedContent.text ?? ""
+      : null;
+  const shouldVerifyReadback =
+    inputs.sink.verifyReadback === true &&
+    proposed.preserve?.opaqueFragments === true;
+  const readbackFailureReason =
+    shouldVerifyReadback &&
+    documentHashAfter === documentHashBefore &&
+    posture === "direct-edit" &&
+    !readback
+      ? `apply-readback-unresolvable:${proposed.targetHandle.scopeId}`
+      : shouldVerifyReadback &&
+          documentHashAfter === documentHashBefore &&
+          posture === "direct-edit" &&
+          proposed.operation === "replace" &&
+          proposedText !== null &&
+          proposedText !== resolvedScope.content.text &&
+          readback?.scope.content.text === resolvedScope.content.text
+        ? `apply-readback-unchanged:${proposed.targetHandle.scopeId}`
+        : undefined;
+
+  if (readbackFailureReason) {
+    return {
+      applied: false,
+      reason: readbackFailureReason,
+      validation: {
+        safe: false,
+        posture: "hard-refusal",
+        blockedReasons: Object.freeze([readbackFailureReason]),
+        warnings: verdict.warnings,
+      },
+      plan,
+      scope: readback?.scope ?? resolvedScope,
+      authoredRevisionIds: Object.freeze([]),
+    };
+  }
 
   const authoredRevisionIds: string[] = [];
   for (const id of Object.keys(docAfter.review.revisions ?? {})) {