Copying from chat erased the lineage

The paragraph was good enough to keep and impossible to explain a week later.

I had asked a model to rewrite part of a K81R retrospective from a selected evidence set. The response tightened the opening and preserved the important technical distinction. I copied it from the chat pane into the document, adjusted two sentences, and continued writing.

When I returned, the paragraph looked authored and carried none of its history. Which evidence had supported it? Which source revisions had been available? What had the model written, and what had I changed? Had I accepted a proposal or merely pasted text that happened to be useful?

Copy and paste had crossed an authority boundary while erasing the crossing.

V0M3 began with that failure.

The chat retained the wrong history

The conversation contained the prompt, response, and several source excerpts. It did not know the document revision into which the paragraph landed. After I edited the paragraph, the transcript no longer matched the document. Later questions added unrelated context and made the original task harder to isolate.

The document knew its current text and not where the paragraph came from.

Two histories existed:

• A conversation ordered by messages.
• A document ordered by revisions.

Copying connected them through human memory. No durable object represented the proposal, target, evidence, acceptance, or subsequent edit.

The chat transcript was useful workspace and a poor document state model.

A paste looked like authorship

Once inserted, generated text inherited the typography and authority of the document. A reader could not distinguish:

• Original authored prose.
• Generated alternative not yet reviewed.
• Accepted generated text.
• Human revision of an accepted proposal.
• Quoted or paraphrased source material.
• Unsupported model invention.

I did not want the final document to display a permanent badge on every generated phrase. I did need the editing system to preserve how text entered and who accepted it.

Visual calm at reading time required stronger state during writing time.

The proposal became its own artifact

V0M3 stored a proposal before it could enter the document:

proposal_id
task_id
target_document_revision
target_range
input_evidence_set
model_and_prompt_revision
generated_operations
validation_state
review_state

The original model output remained immutable. A reviewer could annotate, edit into a new proposal revision, accept selected operations, or reject it.

Acceptance created a document revision referencing the exact proposal and patch. It did not mutate the proposal into “accepted text.”

This separated what was suggested from what the document became.

“Improve this” was insufficient provenance. A proposal needed to know what kind of change it was allowed to make.

V0M3 tasks included:

• Shorten while preserving every supported claim.
• Rewrite for chronological clarity.
• Insert a transition using only selected evidence.
• Flag unsupported assertions without changing prose.
• Propose headings for one section.
• Compare current text with a source revision.

The task stored target, constraints, allowed operation types, evidence, and completion criteria. A model could produce attractive text that failed the task.

Review compared the proposal with the requested transformation, not only with taste.

The copied paragraph had landed after the document changed. V0M3 bound each task to an exact document revision and source range.

If the document changed before acceptance, the proposal became stale. The system could show a three-way comparison among target revision, current revision, and proposed operations. It never applied the old range by position to new text automatically.

Stable block and span identities helped locate unchanged targets. They did not override a changed semantic context.

The reviewer chose to rebase, regenerate, adapt manually, or reject.

Evidence remained attached to the proposal

The rewrite consumed a K81R evidence-set revision. V0M3 stored those exact source units, their access scope, and the mapping between proposed claims and evidence.

Opening the proposal showed:

• Source text being changed.
• Proposed operations.
• Evidence and source revisions.
• Claim-support checks.
• Gaps or explicit inferences.
• Model and prompt configuration.

A later source update marked the proposal or accepted text potentially stale without rewriting either.

The paragraph could now be traced back through selection and source, not merely through a chat scroll.

A complete rewritten document made comparison overwhelming and encouraged copy-all acceptance. V0M3 generated typed operations:

• Insert after stable block.
• Replace exact range.
• Delete exact range.
• Add comment to range.
• Propose heading move.

Each operation carried a before digest, proposed content, reason, evidence links, and dependencies on other operations.

The review interface could accept one operation and reject another. The resulting patch had a stable identity and document revision.

Granularity made model contribution reviewable rather than smaller-looking.

Model text did not write the document database

The generation worker could create proposal artifacts and had no permission to update canonical documents. Acceptance used a separate command path under current author authority.

The command validated:

• Reviewer may edit the document.
• Target revision and before digests still match.
• Proposed operations are structurally valid.
• Required evidence remains available.
• Review policy is satisfied.
• Patch has not already been applied.

The document service created the new revision transactionally and recorded proposal lineage.

A prompt instruction could not grant write authority.

Human edits were first-class

The first prototype offered Accept or Reject. Useful proposals often needed revision.

Editing generated text created a proposal revision or an authored patch derived from the proposal, depending on the workflow. The diff distinguished model candidate, reviewer change, and final accepted operation. The author could remove an unsupported sentence, restore voice, or combine two alternatives.

The final document remained human-controlled without pretending the accepted language had appeared from nowhere.

Authorship was expressed through acceptance and editing, not through exclusive keystroke origin.

Rejection preserved judgment

Deleting a chat response lost why it was unsuitable. V0M3 allowed a bounded rejection reason:

• Unsupported claim.
• Wrong target or stale revision.
• Voice mismatch.
• Unnecessary change.
• Evidence incomplete.
• Technically correct but weak structure.
• Prefer original.

The original proposal remained under retention policy, linked to evaluation if the failure was reusable. Rejection did not automatically train a model or become a universal quality label.

The author was allowed to say no without proving the proposal was objectively bad.

After acceptance, the text belonged to the document. Ordinary human edits created later document revisions. Lineage could say that a current sentence descended from proposal 42 and changed in revisions 19 and 23.

It did not freeze the paragraph to preserve provenance. It did not require model involvement in future edits.

If a later edit removed the generated sentence, history still showed that it once existed and why it was removed. Current reading remained clean.

Provenance supported evolution instead of turning accepted output into a protected object.

The chat interface's Undo meant regenerate or manually paste the old text. V0M3's acceptance produced an append-only document revision and inverse patch where safe.

Undo created another revision referencing the accepted patch. If later changes overlapped, the interface showed a conflict instead of restoring an old blob over new work.

External exports or publications were not undone merely by changing the document; those consequences had their own records and workflows.

Document history made reversal explicit and bounded.

Citation footnotes were not enough

The copied paragraph had two footnotes. They linked to source documents and did not preserve which claim used which passage, which source revision the model saw, or how the human edit changed the relationship.

V0M3 stored an evidence graph beneath the document:

source revision → evidence unit → generated claim
→ proposal operation → accepted span → later edits

The final export could include ordinary citations and optional provenance. The editing system retained the deeper graph for review.

Footnotes served readers. Lineage served the authored workflow.

A proposal generated from restricted evidence could not be accepted into a broadly shareable document merely by omitting the citation.

Each claim and operation inherited an output-scope ceiling from its evidence. Acceptance validated destination scope. A reviewer could build a new public-only evidence set and produce or author a claim independently supported there.

The system did not assume a person with access could publish every derived fact.

Copying from chat had bypassed this relationship entirely.

Provider differences stayed behind proposals

V0M3 could use more than one model adapter for bounded generation. Providers differed in context limits, structured output, tool behavior, privacy terms, streaming, and resumption.

The proposal record normalized the product contract—task, target, evidence, operations—and retained provider-specific provenance and limitations. A provider could not write a different document state simply because its streaming interface differed.

Comparison created separate proposals against the same immutable task. It did not blend outputs before review.

Malformed output, provider timeout, invalid evidence ID, unsafe markup, or unsupported operation left the canonical document unchanged.

The task and evidence set survived. A generation attempt had known-failed or unknown outcome according to adapter evidence. Recovery could query, retry idempotently where supported, or start a new attempt linked to the same task.

The page showed the current document first and proposal failure second.

Model availability became an optional workflow capability rather than a dependency of document integrity.

The interface put the document in the center

V0M3 did not lead with a permanent chat rail. The canonical document occupied the main reading and editing surface. Proposal operations appeared as a review layer tied to exact ranges. Evidence opened beside the selected claim. Task history lived in a secondary panel.

Animation stopped when generation finished. No glowing assistant avatar competed with the text. The author could hide every proposal and continue ordinary editing.

Visual hierarchy reinforced the state model: the document was authoritative; suggestions waited outside it.

The canonical document exported to Markdown without requiring V0M3 to render it later. Citations used conventional links or notes. An optional sidecar manifest preserved revision, proposal lineage, and source relationships.

If model access, provider APIs, or V0M3 itself disappeared, the document remained readable and editable. Provenance degraded gracefully from rich graph to ordinary revision and citation metadata.

The assistant could help create the artifact without becoming its runtime.

The original paragraph became a migration fixture

I reconstructed the copied paragraph as closely as the chat and version history allowed. Several relationships remained unknown, and I labelled them unknown instead of inventing provenance.

The fixture then exercised the new path:

1. Create task against document revision.
2. Select evidence set.
3. Generate structured operations.
4. Validate claim support and target digests.
5. Review and edit one operation.
6. Accept the patch into a new revision.
7. Edit the paragraph later.
8. Export document and provenance sidecar.

The same useful prose could now enter without erasing how it arrived.

V0M3 did not block ordinary paste. Text can come from notes, editors, people, or tools outside the system. It recorded pasted insertion as an authored edit unless the user explicitly attached external provenance.

The product did not pretend to detect generated text by style. It made the governed assistance path easier when lineage mattered.

This preserved author agency and avoided false attribution.

The boundary changed the project

K81R had focused on whether an answer was supported. V0M3 faced a harder problem: what happens when supported generated language enters a document that people continue to change?

The answer could not be a better chat transcript. It required document revisions, proposal state, target identity, evidence lineage, acceptance authority, undo, portability, and visual hierarchy.

Copying from chat erased that structure because none existed.

V0M3 began by making one useful paragraph wait at the document boundary until its history could cross with it.

The final check copied the accepted paragraph into a plain editor and back again. Its rich lineage did not survive that external round trip automatically, but the text did, and V0M3 refused to fabricate an origin when it returned. Portability and provenance remained compatible because losing optional metadata produced an honest authored paste, not a broken document or a guessed history.

Pasted citations were validated separately

Copying a generated paragraph often copied footnote markers without their source records or pasted URLs whose target later changed.

V0M3 parsed pasted citation-like content as text first. The author could attach it to an existing K81R source revision, import a reviewed external reference, or leave it as an unverified link. The system never inferred that a matching title established provenance.

When an attached source supported only part of the paragraph, claim review exposed the boundary. Citation cleanup became an evidence task rather than formatting after paste.

For copying within V0M3 and K81R, the clipboard included ordinary text plus a private structured flavor containing source or proposal identities. A destination under the same authorized session could offer to preserve lineage. Other applications received only portable text.

The structured data was signed or validated by the server-side session and never trusted because a browser supplied it. Access and document scope were rechecked on paste. Expired or unavailable provenance degraded to ordinary text with a clear warning.

This improved local workflows without making rich clipboard metadata necessary for the document to survive.

Diff quality depended on stable document structure

Character diffs made paragraph rewrites noisy and could not tell whether a heading move, paragraph replacement, or citation change was intended.

V0M3 represented the document as authored blocks with stable identities inside an immutable revision. Proposal operations targeted block and span IDs plus before digests. The review view combined structural and text diffs: moved block, replaced range, inserted claim, removed citation.

Stable identity survived unchanged blocks across revisions. A substantial rewrite could deliberately create a new block. The system did not force false continuity to keep diffs small.

The model could propose a comment such as “This claim lacks evidence for the adapter version.” A chat response often caused me to edit immediately and lose the critique itself.

V0M3 stored comments as review artifacts attached to a target revision and range. Resolving a comment could link to the document patch or evidence-set change that addressed it. Comments never entered exports unless requested.

This allowed assistance to improve reasoning without always supplying replacement prose. Sometimes the best proposal was a precise question.

Batch acceptance preserved operation dependencies

A proposed heading move could depend on inserting a transition. Accepting one and rejecting the other might leave an awkward document.

Operations declared dependencies and conflicts. The review interface grouped them, explained consequences, and still allowed the author to break the group by editing a new proposal revision. Acceptance validated the exact chosen set against the target document.

The model did not control grouping authority. Dependencies were suggestions checked against document structure and reviewer choice.

Review effort had a visible budget

Generating ten alternatives could make each individually reviewable and collectively exhausting. V0M3 limited default proposals by task, showed changed word and operation counts, and asked for a narrower target when a patch exceeded the configured review budget.

The author could deliberately request a large rewrite. The interface then changed mode to section comparison and required explicit acceptance per structural unit.

Assistance quality included the amount of judgment it asked the author to perform.

Provenance did not become visual clutter

During writing, a subtle gutter marker indicated spans with proposal lineage or unresolved evidence. Selecting it opened the graph. During ordinary reading and export, the prose remained primary and citations followed normal conventions.

The author could inspect contribution history without every sentence wearing a permanent origin badge. Accessibility labels exposed review state where it affected action, not decorative metadata on every token.

The quiet surface depended on rich state remaining available on demand.