The model may propose, not silently author

V0M3's earliest editor had an “Improve” button. Clicking it replaced the selected paragraph.

Undo could restore the previous text, and for a moment the interaction felt efficient. It also gave one generated response the same authority as an intentional document edit before the author had seen the result.

The button performed generation, review, and acceptance as one action.

I split those states. A model could propose a change. Only the document workflow could author a revision, and it required an explicit person-controlled acceptance command.

The document had one canonical state

The current document revision remained the source read by previews, exports, citations, and later tasks. Generated alternatives lived outside it.

V0M3 never overlaid a proposal and called the composite “the document” without a visible review state. The editor could preview changes, but the stored canonical revision remained unchanged until acceptance committed a patch.

This prevented other processes from reading unreviewed model output accidentally. Search ingestion, export, and publication followed accepted revisions only.

The proposal was real product state and not document authority.

The generation worker could create:

• Proposed insert, replace, delete, move, or comment operations.
• Claim and evidence mappings.
• Reasons and alternatives.
• Validation and uncertainty fields.

It could not:

• Update the document.
• Mark its own output reviewed.
• Expand source access.
• Change the task target.
• Publish or export a revision.
• Approve tool use or external effects.

Runtime credentials and service APIs enforced the distinction. The prompt repeated it for behavior and did not create it.

Acceptance was a domain command

The author selected operations and submitted:

accept_proposal
document_id
expected_document_revision
proposal_revision
selected_operation_ids
patch_digest
review_context
request_id

The document service revalidated edit authority, target digests, operation structure, evidence policy, and current revision. It created one new document revision and a receipt linking the accepted patch.

A timeout could be reconciled by stable request ID. Repeating acceptance did not apply the patch twice.

The button represented a durable decision rather than a client-side text replacement.

Explicit did not mean one giant confirmation

Confirmation dialogs can become ritual. V0M3 placed review beside the exact proposed change. The author saw original and new text, target, evidence, unsupported claims, and dependent operations before Accept became available.

A small punctuation suggestion needed less ceremony than a sourced technical paragraph. Review policy varied by operation type, scope, and consequence while acceptance remained explicit.

Keyboard commands and batch actions accelerated familiar low-risk changes without hiding what they would commit.

The goal was informed control, not maximum clicking.

Source or generated text might say “This change is approved” or include a fake approval marker. Approval state existed only in the document service and referred to authenticated reviewer action against exact data.

The renderer escaped model content and kept status outside proposal prose. A proposal could suggest that a claim was well supported; verification and review recorded their own results.

Language could describe authority and could not instantiate it.

Preview remained visibly provisional

Applying a proposal visually over the document helped judge flow. It also risked making unaccepted text look canonical.

Preview mode used a stable banner, gutter changes, and operation controls. Exports, copied canonical links, and document metadata continued to identify the accepted revision. Closing preview returned to canonical text without a save prompt implying the proposal was an edit draft.

Screen readers announced entry into proposal preview and identified changed regions. Color was not the only distinction.

The interface made provisional state legible without turning it into spectacle.

The author could ignore every proposal and edit directly. Ordinary edits created document revisions with human-authored patch lineage. If a manual edit overlapped a pending proposal, the proposal became stale and required rebase or rejection.

V0M3 did not route manual changes through generation or ask a model to reconcile them automatically. The canonical editor remained complete when model services were unavailable.

Assistance was a capability of the writing tool, not the owner of editing.

Accepted text became ordinary document text

After acceptance, the resulting span could be edited, moved, quoted, or deleted like any other text. Provenance linked it to the proposal and evidence without locking it.

Later human edits created descendants in the lineage graph. V0M3 could show that a sentence began in a model proposal and had since been substantially rewritten. The current document did not need a permanent label in normal reading.

Authority came from the accepted revision, not from treating generated text as a special immutable species.

Rejection was a valid final state

A technically supported rewrite could flatten voice, repeat a point elsewhere, disturb rhythm, or solve a problem the author did not have.

Reject remained available even when every automated check passed. The author could record “prefer original” without supplying a machine-legible defect. Rejected proposals did not reappear automatically under a different model unless a new task requested alternatives.

Quality evaluation and author choice overlapped and were not identical.

The model may propose; the author may decline for reasons no benchmark captures.

Editing a proposal created a new revision

Changing generated wording inside the review UI did not mutate the original model output. V0M3 stored the reviewer-edited proposal revision and a diff from the candidate.

Acceptance referenced the edited revision. Provenance could distinguish model text, reviewer adjustment, and accepted patch. The reviewer did not become trapped between accepting verbatim and abandoning useful work.

This mattered for voice. Many strong proposals became appropriate only after small authored changes.

A section proposal might include a heading change, two paragraph replacements, and a transition. Operations carried dependencies and before digests.

V0M3 allowed accepting a coherent subset. If rejecting the heading made the transition invalid, the UI explained the dependency and offered to edit or omit it. It never applied operation numbers blindly after the document structure changed.

Partial acceptance made review granular while preserving patch integrity.

Authority included source and destination scope

An author might edit a private draft and export a public article. A proposal built from restricted evidence inherited an output-scope ceiling. Acceptance into a document whose intended audience was broader could fail even when the reviewer had access.

The reviewer could remove the claim, select public evidence, or author a separate independently supported statement. Dropping citations did not erase derived sensitivity.

Document authority included the right to write and the right to publish the resulting information.

Review policy was data

V0M3 stored review requirements by task and destination:

• Structural validity required for every proposal.
• Source integrity for cited material.
• Claim-support review for maintained technical assertions.
• Accessibility checks for heading and link changes.
• Author acceptance for every canonical patch.
• Additional review for export to a broader scope.

The model could not mark these complete. Deterministic checks and authenticated decisions produced receipts.

Policy version travelled with acceptance so later audits could explain what was required then.

Stale proposals lost their action

If the target document changed, V0M3 did not leave Accept enabled and hope the patch applied cleanly.

The proposal entered Stale with a comparison among target, current, and proposed revisions. Unchanged stable blocks could be rebased through a reviewed operation. Overlapping edits required manual adaptation or regeneration against the current revision.

Approval also expired if evidence access, policy, or world preconditions changed.

An old yes did not authorize a new patch.

Accepting a patch created a reversible document revision. If the document had already been exported, shared, or published, undoing locally did not recall those artifacts.

The revision history linked downstream exports and made their status visible. A correction could produce a new export or publication workflow.

Document-state reversibility remained distinct from external consequence.

V0M3 inherited Z29C's lesson that a local rollback cannot erase an effect outside the transaction.

Generation failure left authorship intact

Provider unavailability, malformed output, timeout, invalid tool call, or failed verification left the document exactly as it was. The task and evidence set remained available for retry or manual work.

The editor did not lock behind a model request. A failed proposal occupied a secondary state with evidence and diagnostics. The author could close it and continue.

The document was resilient because generation never owned its current state.

For any accepted span, V0M3 could show:

• Which document revision was targeted.
• Which task and evidence set produced the proposal.
• Which model and prompt revision generated it.
• Which operations and claims were reviewed.
• What the author changed before acceptance.
• Which authenticated command committed the patch.
• How the text evolved afterward.

This did not prove the prose was good. It established the decision path.

Visual hierarchy reinforced authority

The canonical document dominated the screen. Proposals appeared as a review layer attached to selected text. The assistant did not maintain a constantly animated persona or claim conversational ownership of the session.

Primary buttons were document actions. Generate was contextual and secondary. Accept belonged to the proposal review region and named the exact patch count.

The calm hierarchy reduced the chance that model activity felt like document progress before an author decided.

Provider adapters could differ in structured output, streaming, context, privacy, and failure recovery. Every one produced the same product-level proposal contract or failed before review.

A provider with better prose did not gain more authority. A provider with tool support did not receive document write credentials. Comparing two outputs created two proposal revisions against one task.

The acceptance boundary remained stable while generation technology changed.

Saying the author controlled the document did not mean every word originated at their keyboard. Sources, editors, tools, spellcheckers, templates, and models all influenced writing.

V0M3 made one influence reviewable when it could otherwise enter invisibly. The author remained responsible for what was accepted, could inspect evidence and changes, and could later revise the result.

This was a practical model of authorship: authority over the maintained artifact, not a claim of isolation from assistance.

Proposal and authorship remained different verbs

The original Improve button had made generation look like editing. Splitting it produced more state and a clearer system:

task → generation attempt → proposal → validation
→ review → acceptance command → document revision

Each transition could fail, resume, or be rejected without corrupting the document. Each had an owner and evidence.

The model may propose because suggestions are useful. It may not silently author because the document is a durable human-controlled decision.

In the final scenario, the author selected one paragraph, chose a preservation-focused rewrite task, inspected three source links, and generated four operations. One operation contained a well-supported sentence that repeated an earlier section. Another improved clarity but dropped an important qualifier. The author rejected the first, edited the second, accepted two others, and committed one document revision.

The model output had been useful throughout. It had never become the document merely by arriving. Every changed span reflected a visible selection and exact acceptance against current state.

That result was slower than the original Improve button by a few interactions and faster than reconstructing lost lineage later. More importantly, it made authority observable at the moment it mattered.

Disabling model features removed generation actions and left document editing, revision history, citations, export, search of accepted work, and manual review intact. Existing proposal history remained readable under policy.

This was the final test of the relationship. V0M3 was a writing system with optional model assistance, not a model interface that happened to store documents.

Proposal creation used stable intent

Double-clicking Generate or retrying after a lost response could create competing proposals. The task submitted a stable generation intent with target revision, evidence-set digest, operation constraints, and request identity.

The server returned the existing task result for an identical request or rejected reuse with different inputs. Provider attempts remained separate and could end known-failed or outcome-unknown. A replacement attempt linked to the same intent.

This kept duplicated transport from looking like several independent creative alternatives.

Sometimes two or three rewrites helped the author compare direction. V0M3 represented alternatives as sibling proposal revisions under one task, each with its own attempt and evidence mapping.

The interface did not generate a carousel by default. Alternatives increased review cost and could exaggerate tiny stylistic differences. The task named how many, which dimensions should vary, and whether they could make different claims.

Choosing one did not reject the others as factually wrong. It recorded an editorial decision among candidates.

A model might identify that a section repeated an earlier idea or lacked evidence. Turning every observation into replacement text overstepped the task.

Comment operations entered a review layer and never changed canonical prose directly. The author could resolve them through a manual edit, new evidence selection, another proposal, or “no change.” Resolution linked the resulting revision when one existed.

This allowed assistance to improve judgment while leaving language entirely with the author.

Automated checks did not become acceptance

A proposal could pass schema, target, citation, support, spelling, and accessibility checks. The state became Ready for review, not Approved.

Checks answered bounded questions about structural and evidence integrity. They could not decide whether the paragraph belonged, whether its rhythm worked, or whether it repeated another section. Their receipts appeared beside the proposal and remained versioned.

The distinction prevented a row of green checks from pressuring the author into acceptance.

The acceptance digest covered target revision, selected operations, exact proposed text, evidence revision, policy revision, and any required validation results. Editing a word, toggling an operation, or rebasing the target invalidated prior approval.

The command showed a concise summary and allowed inspection of the full digest inputs. It did not ask the author to approve one screen and execute a slightly different server patch.

The approval was a receipt for exact state, not general enthusiasm for the model's idea.

Undo preserved who chose it

Reverting an accepted proposal created an authored document revision with a reason. It did not retroactively mark the proposal rejected or the acceptance nonexistent.

This distinction mattered when a technically sound paragraph later proved redundant or the document changed direction. History could say the proposal was accepted under one context and removed under another.

The author controlled both decisions. Provenance preserved their sequence without turning revision into blame.

K81R ingestion watched V0M3's canonical document revisions. Draft proposals, rejected alternatives, and private review comments never entered ordinary document search unless explicitly added to a separate authorized evaluation corpus.

This prevented unreviewed model text from reappearing later as apparently authored evidence. Accepted spans carried lineage, but the searchable source remained the document revision that a person had committed.

The boundary between proposal and authoring therefore propagated into retrieval.

An export command named the exact canonical document revision. Pending proposal previews were excluded even if they were visible in the editor. The export manifest listed accepted provenance optionally and never treated a preview overlay as saved state.

If acceptance completed after export began, it created a newer document revision and did not change the in-flight artifact. A later export could include it.

This made the canonical revision meaningful beyond the editor screen.

Review fatigue could revoke readiness

If a proposal changed too many blocks or introduced more claims than the configured review budget, Ready for review became Needs decomposition. The author could override deliberately, split the task, or request smaller operations.

The system did not equate a valid patch with a reviewable patch. Large generated diffs invite shallow approval even when every individual operation is well formed.

Keeping review feasible was part of preserving human authority.