Whole-section rewrites are hard to review

V0M3 rewrote a 900-word section into a smoother 760-word section. The diff showed almost every line as changed.

The proposal removed one repeated paragraph, tightened two definitions, moved a limitation earlier, changed several transitions, and invented one unsupported causal sentence. All six decisions appeared as one replacement blob.

Reviewing it required rereading the old section, reading the new one, mentally aligning claims, checking sources, and remembering which differences I liked. The text was shorter; the review task was larger.

I stopped asking the model to return one rewritten section and asked it to propose explicit operations.

A diff measured text, not intent

Character and line diffs were useful for exact change and weak at explaining why prose moved.

A paragraph moved with two word changes could appear as one deletion and one insertion. A transition rewrite could make neighboring lines look different. Reflow or formatting could dominate the view while a new technical claim hid inside a familiar paragraph.

V0M3 kept the ordinary text diff and added an operation model. The model output had to state which authored object it intended to change and how.

Review could then follow decisions before pixels.

The initial set included:

• Insert block before or after stable block.
• Replace exact span inside block.
• Delete block or exact span.
• Move block within a declared section.
• Add review comment to target.
• Replace heading while retaining section identity.

Each operation carried target revision, block and span IDs, before digest, proposed content, reason, evidence links, and dependencies.

The schema prohibited a generic “replace document” operation for ordinary assistance. Large migrations used a different review mode.

Typed operations made the model's write scope visible.

Reasons were review aids, not evidence

The model supplied a concise reason: remove repetition, clarify a term, preserve chronology, or surface a limitation earlier.

Reasons helped the author scan and could be wrong. They were generated interpretation, not proof that the operation achieved its goal. Source evidence remained separate. The author could edit or ignore the reason without changing the proposed patch.

I did not let a persuasive explanation increase acceptance authority.

The operation had to stand in the document and evidence view.

A replacement might preserve two supported claims and introduce one new assertion. V0M3 mapped claim candidates to the exact inserted text and evidence units.

The review card showed:

• Claims retained from target.
• Claims reworded with unchanged scope.
• Claims removed.
• New claims and their support state.
• Changed qualifiers, quantities, time, or modality.

An operation containing an unsupported new claim could be edited or rejected without losing unrelated improvements elsewhere.

Claim-level review made the dangerous sentence easier to find than a red-green diff did.

Moves remained moves

The limitation paragraph belonged earlier. A text diff treated the action as deletion and insertion, obscuring that the same authored block persisted.

The move operation kept block identity and history. If content changed too, V0M3 represented a move plus a bounded replacement. The review UI showed old and new context side by side.

Moving a paragraph could change interpretation even without changing words. The operation therefore required editorial review and invalidated heading- or neighbor-dependent comments when appropriate.

Structural identity reduced noise without declaring moves semantically harmless.

Generated rewrites often improve flow by omitting inconvenient material. A delete operation showed exact removed claims, citations, comments, and downstream references.

The model reason could say “repeated above,” and V0M3 linked the alleged earlier span. The author could verify whether the repetition was real or whether each paragraph served a different context.

Deleting a cited limitation required explicit acceptance. A configured review rule could block batch acceptance until its evidence and dependent claims were inspected.

Absence became a decision rather than a side effect of rewrite.

Inserts declared their relationship

An inserted transition could be stylistic, a factual claim, an inference, or a signpost. The operation labelled its type.

Stylistic text still passed rendering and target checks. Factual text required evidence. An inference showed premises and review state. A signpost referenced sections that had to exist in the target revision.

This prevented connective language such as “therefore” from introducing unsupported causation invisibly.

The smallest sentences could carry the biggest reasoning change.

Sometimes the model saw a problem and had no trustworthy rewrite. A comment operation could say that a term was undefined, a claim lacked current evidence, or two paragraphs contradicted each other.

Comments stayed outside canonical prose and attached to exact target state. The author could resolve them through manual edit, evidence work, another proposal, or no change.

This reduced pressure on generation to solve every detected issue with more generated text.

Assistance could improve the review without supplying the language.

Dependencies kept partial acceptance coherent

A heading change might require updating a transition. Moving a limitation might make a deletion safe. Operations declared required, optional, and conflicting relationships.

The interface grouped dependent changes and explained what rejecting one would do. It did not force all-or-nothing acceptance; the author could edit a new coherent subset.

The server validated the selected operation graph before applying it. A missing prerequisite stopped the patch even if the client overlooked the warning.

Partial acceptance became deliberate composition, not checkbox roulette.

Applying a deletion before a range replacement could invalidate offsets. V0M3 normalized operations against stable target identities and computed an ordered patch plan.

The plan detected overlapping writes, move cycles, duplicate targets, and insertions whose anchors were deleted. Conflicts returned to proposal review. The model's output order did not govern execution merely because it streamed first.

Acceptance digested the normalized plan. Reordering changed the patch and invalidated approval.

Streaming used complete operations

Raw token output could show half a replacement before its target or evidence arrived. V0M3 buffered one complete operation, validated schema, target, source IDs, and safe rendering, then revealed it as a review card.

Operations could arrive progressively in planned section order. The author could inspect early cards while later ones generated. The document preview did not apply them until a coherent selected set existed.

The unit of progress matched the unit of possible acceptance.

Small span edits used inline before-and-after. Paragraph changes used split or unified views. Moves used structural context. Multi-block changes added an outline view showing section order and claim coverage.

The author could switch to raw text diff at any time. V0M3 did not hide exact wording behind semantic summaries.

One universal diff would optimize for implementation uniformity and make large or structural changes harder to judge.

The original remained easy to choose

Every operation card had Keep original as a first-class action. Rejecting did not require editing the proposed text into an empty patch or explaining a defect.

Batch controls defaulted to no change. V0M3 never preselected all generated operations because validation passed. The author had to choose acceptance, individually or through a reviewed group.

This resisted automation bias at the interface level.

The task declared maximum changed blocks, new claims, deleted claims, and approximate changed words. Exceeding the budget produced Needs decomposition rather than a giant valid patch.

The author could override for an intentional restructure. The UI then required section-level review and disabled one-click acceptance.

Reviewability was part of the proposal contract. The system did not optimize token generation while treating human attention as unlimited.

Accessibility applied to review UI

The operation list used headings, change types, target labels, and status text. Keyboard commands moved among operations, original text, proposed text, claims, and evidence. Screen-reader users could hear “Replace paragraph, one new unsupported claim” before opening detail.

Moves described source and destination structurally. Color was not the sole indicator of insert or delete. Focus returned to the operation after evidence inspection.

Review granularity had to improve access, not create a visual-only diff system.

If another edit changed one target block, V0M3 marked only affected operations stale. Independent operations against unchanged blocks could remain reviewable under a new proposal revision after exact revalidation.

Context changes at section level could mark a wider group for editorial review even without text overlap. Acceptance always targeted one current document revision, so the selected set was rebased and redigested together.

Granular operations enabled granular conflict without bypassing final atomic commit.

Acceptance created one document revision

Selecting five operations did not create five transient canonical states. The document service applied the validated plan transactionally and appended one revision with operation and proposal lineage.

If any selected operation failed its precondition, none committed. The response returned the current revision and conflict detail.

The author reviewed pieces and authored one coherent document state.

V0M3 could compute an inverse for accepted inserts, replacements, deletes, and moves against the immediate child revision. Later overlapping edits made a simple inverse unsafe.

Undo therefore created a new proposal against current state, showed conflicts, and required acceptance. It did not overwrite later work with the old section blob.

Reversibility inherited the same target and review rules as forward assistance.

Evaluation scored operations and document result

An operation could be individually correct and compose poorly with accepted neighbors. The test suite checked:

• Target and before-digest validity.
• Operation-schema and dependency correctness.
• Claim and citation preservation.
• Unsupported additions and silent deletions.
• Final heading and document structure.
• Voice and redundancy through review fixtures.
• Accessibility of the resulting document.

Model graders could assist with prose qualities. Deterministic state and source checks remained independent.

The final document mattered more than a sum of acceptable cards.

In the 900-word fixture, V0M3 produced eight operations. I accepted the definition edits and paragraph move, edited a transition, rejected the unsupported causal sentence, and kept one paragraph the model called repetitive.

The resulting section was not either original or generated rewrite. It was an authored revision informed by a reviewable proposal.

Every accepted span had target, evidence, and decision lineage. Rejected operations remained outside the document.

Whole-section rewrites are hard to review because they compress many editorial decisions into one attractive alternative. Typed operations expanded those decisions just enough for the author to own them.

Review became authorship again.

The original blob remained a regression fixture

I preserved the first 760-word rewrite and manually decomposed its decisions. Future models and operation compilers had to identify the unsupported causal sentence, retain the limitation, express the move structurally, and avoid classifying the kept paragraph as an automatic deletion.

The fixture evaluated reviewability as well as final prose. A candidate failed if it produced an equally attractive section whose meaningful changes could not be isolated. This prevented better wording from returning the product to one opaque replacement.

V0M3 did not turn every token into an operation. Word-level acceptance would make prose impossible to judge and create false precision about origin. The smallest normal unit was a meaningful span change inside one block, with claim mapping when factual meaning changed.

The author could still edit any word manually. Operation granularity existed to expose decisions, not to count which agent supplied each character.

A rewrite could normalize punctuation, link style, or Markdown wrapping across the section and drown semantic edits in noise. V0M3 separated formatting-only operations where the transformation was deterministic and supported.

The review could hide or batch those operations after checking the rule once. Generated prose changes could not label themselves formatting-only; the application compared parsed document structure and text semantics under bounded rules.

This kept a typography cleanup from giving an unsupported sentence visual cover.

Moving a paragraph could preserve its citation links. Replacing one sentence might invalidate only one claim-source edge. Deleting a claim could leave an unused footnote.

Operations declared citation effects: preserve edge, replace support, remove edge, or add source. The final patch validator checked that every retained citation had a target claim and every required claim had evidence according to policy.

The review showed orphaned sources and claims separately. Citation cleanup became part of the operation, not a manual sweep after acceptance.

Provider output passed one operation compiler

Some providers returned structured records directly; others returned text that needed constrained parsing. Every adapter produced the same untrusted proposal AST before V0M3 created product operations.

The compiler validated allowed types, target membership, ranges, text limits, source IDs, dependency graph, and rendering policy. Unknown constructs failed. It never executed a provider-supplied patch or path.

Provider convenience changed adapter work, not document authority or review semantics.

Regenerating one failed operation could produce a different alternative. V0M3 created a new operation ID linked as replacement-for, rather than overwriting the old card.

Already reviewed operations stayed reviewed only if their exact content, target, evidence, and dependencies were unchanged. A new reason alone did not matter to patch identity; a text or source change did.

This prevented a regenerated batch from carrying old checkmarks onto new words.

Live document edits did not reshuffle the review list

While a proposal was open, another tab could edit the document. V0M3 preserved operation order and target revision in the review. It added staleness indicators instead of reordering cards around the latest text automatically.

The author could finish reviewing the historical proposal, then run one explicit rebase across selected operations. This kept the review artifact stable enough to understand.

Currentness mattered at acceptance; legibility mattered while comparing.

A delete operation over a block with citations, comments, incoming links, or accepted generated lineage opened a consequence panel before selection. The panel named dependents without implying deletion was forbidden.

The author could update references in the same patch, preserve a tombstone where a stable link mattered, or accept broken historical links only under a deliberate migration rule.

Text deletion became document-graph maintenance when the archive depended on the block.

Review time was measured without surveillance

For synthetic scenarios, I measured time and actions needed to identify planted unsupported claims under blob and operation review. Operation review reduced search effort and sometimes increased total clicks.

I did not collect detailed ordinary writing behavior indefinitely. Explicit reviewer feedback and bounded study runs informed the design. The result was qualitative: reviewers could point to one decision and preserve the rest.

Human attention was a product constraint, not a metric to harvest continuously.

Typed operations could make the model's holistic alternative hard to read as one piece. V0M3 offered a non-authoritative assembled preview using the proposed operation set.

The preview carried the same provisional state, selected operation revision, and warnings. It never became the source for acceptance; the normalized operation plan did. Differences between preview and plan failed validation.

The author could judge overall rhythm without giving up granular control.

Adding a new block type or heading rule could make an old proposal operation unsupported. V0M3 kept the target document-schema version and operation-schema version.

An explicit proposal migration could translate safe structural forms and produce a new revision. Unsupported cases stayed historical and non-actionable. The system did not reinterpret old generated JSON under today's compiler silently.

Proposal longevity required versioning the language in which changes were expressed.

Batch acceptance had a confirmation summary

Before commit, the page summarized: four replacements, one move, zero deletes, two new supported claims, one edited model sentence, and no unresolved evidence gaps. The author could open every item.

The summary was computed from the exact normalized patch digest, not generated prose. Any change invalidated it. The server returned a receipt containing the same counts and new document revision.

This made a batch decision compact without becoming vague.