The evidence set should exist before the answer

K81R's original evidence set existed for milliseconds.

The retriever selected five chunks, a prompt builder concatenated them, the model generated an answer, and the temporary array disappeared. The interface preserved the polished output and citations. It did not preserve the selection decision that had shaped every claim.

When the answer was wrong, I could reconstruct candidates from logs if the index had not changed. I could not show what a reviewer would have removed, expanded, or contradicted before generation.

I promoted the evidence set from a prompt implementation detail to a product object.

Selection was a consequential transformation

Retrieval returned candidates. Selection decided which candidates became available to synthesis.

That stage could:

• Exclude a current decision because of a top-k limit.
• Include a semantically close but neighboring process.
• Drop the paragraph containing an exception.
• Prefer one side of a contradiction.
• Attach too little context to a table or list.
• Include sensitive text outside the intended output scope.

The model could not cite evidence it never received. It could also infer from a biased set without knowing the set was incomplete.

Making selection visible gave that responsibility an interface and history.

The object had an immutable revision

An evidence set stored:

set_id
revision
task
question
corpus_scope
index_generation
selected_units
selection_order
notes_and_gaps
created_at

Each selected unit referenced immutable source revision and spans, heading context, structural expansion version, retrieval query, lane ranks, authority status, and access decision.

Adding, removing, reordering, or expanding evidence created a new set revision. An answer referred to exactly one revision. Revisiting the set later did not silently change the sources behind historical prose.

The set could evolve. Its past remained inspectable.

Automatic selection was a draft

K81R still proposed an initial set from hybrid retrieval. I did not require manual assembly from an empty page.

The proposal was labelled Draft evidence. It showed why each unit was selected and which candidate rank supplied it. A reviewer could:

• Remove a weak source.
• Expand to the surrounding section.
• Replace a superseded document with its current relation.
• Add a contradicting passage.
• Pin an exact identifier result.
• Mark a missing premise.

The automatic set saved time without pretending neutrality.

Generation remained unavailable until the set passed structural and access validation; review could be optional for low-consequence drafting and required for maintained outputs.

Evidence units were not raw chunks

A selected unit included the matched source node and the context required to interpret it. A list item travelled with its introduction. A table row kept headers. A code block kept its declaration and source lines. Heading lineage remained visible.

The set distinguished:

• Retrieval representation used for ranking.
• Context envelope supplied to generation.
• Exact support span later attached to a claim.

These layers often differed. One vector chunk might find the section; the evidence unit could expand it; a claim might cite one sentence inside it.

The product stopped calling all three “the chunk.”

The automatic pipeline tried to select internally consistent passages. That made answers fluent and could hide a real disagreement in the archive.

Evidence sets supported relation labels:

• Supports.
• Contradicts.
• Supersedes.
• Historical context.
• Defines a required term.
• Supplies a missing condition.

These labels came from document metadata or reviewer annotation and retained provenance. They were not model-generated truth by default.

An answerability check could decide that supersession resolved a conflict for a current-state question. If two active documents disagreed, the set made the contradiction a result rather than smoothing it into prose.

Gaps were first-class entries

A blank set field called “notes” quickly became vague. I introduced structured evidence gaps:

• Missing entity identity.
• Missing time or revision.
• Missing authority or status.
• Missing condition.
• Conflicting active sources.
• Inaccessible required evidence.
• Outside corpus scope.

A gap linked to the task clause it prevented the set from supporting. The interface suggested narrower retrieval actions where possible.

The set could therefore be valuable before it was complete. It documented not only what had been found but what remained necessary.

The initial question often changed during research. A reviewer searched an identifier, followed a relationship, removed a date filter, and discovered a current decision.

Each selected unit retained the query and index generation that surfaced it. The set itself stored a compact selection history: automatic proposal, manual search, relationship traversal, or direct source choice.

This history did not imply that higher retrieval rank made a source more authoritative. It explained how the evidence came to attention and helped reproduce failures.

Search history retention was bounded and source selection could remain after raw exploratory queries expired under privacy policy.

Token budget became visible allocation

The model context had a finite limit. The old prompt builder silently truncated later chunks.

The evidence-set page displayed estimated token cost by unit and the budget reserved for task instructions and answer. If the set exceeded the limit, it did not drop evidence automatically. The reviewer could narrow passages, remove redundancy, choose a larger supported context, or request staged comparison.

Structural context rules protected required headings and table headers from being trimmed independently. A unit could be compacted only through a recorded representation with a link to the full source.

The budget became a decision about attention, not an array slice.

Order could bias generation

The same evidence in a different order could change emphasis or which details survived a long response.

K81R offered task-specific ordering:

• Authority then supporting detail.
• Chronological for historical questions.
• Claim requirement order.
• Contradiction pairs adjacent.
• Source order within one document.

The selected order was stored and shown. Evaluation permuted evidence to reveal order sensitivity for critical cases. A result stable only under one convenient order was marked fragile.

I did not claim to eliminate position effects. I stopped leaving order to whichever asynchronous retriever returned first.

Every evidence unit stored the access decision that admitted it. The set had an effective output scope no broader than its most restrictive required source.

Sharing or opening a set revalidated current permissions. An unauthorized viewer saw a redacted unit marker and the resulting answer could be unavailable or partially redacted according to policy. The system never regenerated from hidden evidence for a viewer who could not inspect it.

Removing access did not rewrite the historical record. It changed what the current requester could open or derive.

The evidence set was a governed data object, not copied prompt text.

Source updates produced comparison, not mutation

If a selected document gained a new revision, the set remained linked to the old one. The interface showed that a newer revision existed and offered a diff.

A reviewer could replace the unit, creating a new evidence-set revision. Answerability reran because authority, content, and contradictions might change. Existing answers remained on their original set.

For current-state questions, a stale set could be marked no longer current. It was not silently refreshed behind an unchanged answer.

This preserved the difference between reproducible history and fresh guidance.

I used evidence sets as:

• Reading lists for a design question.
• Support bundles attached to architecture decisions.
• Source collections for a later case study.
• Comparisons of historical and current approaches.
• Review packets for an unresolved contradiction.

The set renderer included source headings, excerpts, relationships, and direct links. Export preserved stable identifiers and revisions.

These outcomes validated retrieval and selection independently of model availability. A generation failure did not erase the research work.

The interface made omission visible

The right rail in the first design showed selected evidence and collapsed everything else. It encouraged the illusion that the visible set was complete.

I added a coverage view mapping task clauses to supporting units and gaps. For “What retry policy applies to adapter X after a timeout?” the clauses were:

• Adapter X identity and version.
• Timeout outcome semantics.
• Idempotency capability.
• Status-query capability.
• Current Z29C policy.

The view showed which sources covered each clause. It did not automatically prove entailment, but an uncovered condition could not hide inside a fluent prompt.

Omission became a visible shape.

Hybrid retrieval often selected several overlapping passages from the same source. They increased token count and gave repeated wording disproportionate influence.

The set grouped overlapping source spans and highlighted redundant meaning. A reviewer could merge context or keep separate passages when each supported a different clause. Text copied into multiple documents remained separate provenance even if embedding computation was deduplicated.

I added a source-diversity diagnostic, not a mandatory quota. Three independent documents were not automatically stronger than one authoritative contract. The goal was to see concentration, not optimize a diversity score.

Reviewers could annotate why a passage mattered or what it failed to establish. Those notes were clearly separate from authored source and never passed to generation as if quoted evidence.

If notes were included as task guidance, the prompt representation labelled them as reviewer instruction with author and revision. A generated answer could not cite the note as a source document.

This protected a subtle provenance boundary: interpretation around evidence is valuable and not identical to evidence.

Generation consumed a manifest

The prompt builder accepted an evidence manifest, not arbitrary text:

• Task and question.
• Effective scope.
• Ordered evidence units.
• Source and support identifiers.
• Known contradictions and gaps.
• Output schema.

It serialized the manifest according to the selected model interface and recorded the exact request. Unsupported or oversize units caused a validation result before generation.

The model still received text. The application retained a structured account of what that text represented.

Answerability could return to the set

When generation or verification found an unsupported claim, the workflow did not merely edit the sentence. It linked the claim to a missing or inadequate evidence unit and reopened the set.

A reviewer could add evidence, narrow the task, remove the claim requirement, or accept a refusal. The next answer used a new set revision and answer record.

This created a loop:

retrieve → select → assess → generate → verify
              ↑                    │
              └──── evidence gap ──┘

The loop improved the research artifact, not only the wording.

The set history recorded product decisions necessary for provenance: source selection, revision, access scope, and acceptance. It did not need a permanent record of every cursor movement, discarded query, or reading pause.

I defined event purpose and retention. Synthetic evaluation runs could retain detailed diagnostics. Ordinary personal exploration kept only saved sets and their explicit revision actions.

Q2F8's principle remained: explainability does not justify collecting every behavior around a decision.

A review state replaced the chat glow

The visual design used ordinary document and selection patterns. Evidence cards looked like sources, not assistant messages. Status labels distinguished Draft, Structurally valid, Gaps present, Ready for synthesis, and Superseded.

No animated border implied that the model was “thinking.” Progress belonged to retrieval or generation jobs with named states. Keyboard and screen-reader flows could traverse task clauses, selected units, gaps, and source links.

The evidence set felt more like a working research document than a magical context tray.

The answer inherited the set's limits

An answer generated from historical-only evidence displayed that scope. One generated from a set missing current adapter capability remained a refusal. One using restricted evidence could not be shared broadly. One produced from an older corpus generation did not silently claim currentness.

These limits were attached to the answer record and visible near the prose. The language could not upgrade the evidence.

The first K81R prototype treated context as temporary fuel consumed by generation. The revised product treated evidence selection as a durable decision with its own identity, review, and consequences.

The evidence set should exist before the answer because the answer can only be as inspectable as the choice of what it was allowed to see.

The decisive test removed one passage after an answer had been generated. The old answer remained attached to evidence revision four and immediately showed that its support was historical. Revision five gained a visible gap and could no longer generate the same claim. Adding a current adapter contract produced revision six, a new answerability result, and a separately inspectable answer. Nothing was overwritten to preserve the illusion of one continuous conversation.

That sequence made the object model worthwhile. Research changed through explicit revisions, and generated prose inherited those changes only through a new decision. The context window had become something a person could inspect before it acquired a voice.

Concurrent editing required an accepted revision

Even in a personal project, the same evidence set could be open in two tabs. One tab removed a superseded passage while another expanded it and saved later.

Save commands included the expected set revision and a stable request identity. A conflicting revision returned both accepted changes and the local operations. The interface could replay non-conflicting additions and required review when the same unit changed differently.

Last-write-wins would have silently changed the evidence behind a future answer. The set reused D4U7's and Z29C's older lesson: preserve intent and make conflict explicit.

I wanted to attach evidence to architecture decisions outside K81R. A plain Markdown export was readable and insufficient for round-trip identity.

The export contained a human-readable document plus a machine-readable manifest of set revision, source IDs, spans, corpus and index generations, relationships, and content digests. Import verified each source against the available corpus and reported missing or changed material.

The readable excerpts were conveniences, not replacement authorities. A disconnected copy could remain useful while clearly identifying the revisions it reflected.

An evidence set duplicated source excerpts and could outlive the query that created it. I classified its purpose: active research, accepted decision support, evaluation fixture, or temporary draft.

Temporary sets expired after a bounded period. Accepted decision support retained references and only the minimum excerpt needed for durable explanation. If a source required deletion or access was revoked, the set recorded a redaction event and preserved non-sensitive structural provenance where policy allowed.

The product did not claim provenance as a reason to retain every copied passage forever.

Model context serialization was inspected

The screen showed structured cards, while the model received a serialized sequence. A bug could omit a heading, merge two sources, or make reviewer notes appear as quoted evidence.

K81R offered a diagnostic “generation input” view containing the exact ordered representation, token counts, source delimiters, and role labels. Sensitive values followed the same access checks as the evidence set. Evaluation compared the manifest with serialized input and failed on missing or extra units.

The context shown to the model became inspectable without expecting ordinary users to read prompt syntax.

Rejecting or deleting a generated draft originally removed the whole chat turn, including its implicit retrieval context.

With separate objects, a generated answer could be discarded while the evidence set remained. Conversely, a temporary set could expire while an accepted maintained document retained its own source references according to policy. Lifecycle was explicit per artifact.

This separation reduced emotional pressure to keep mediocre generated prose because it was the only record of useful source gathering.

A set could be declared insufficient forever

Some historical questions had no surviving source. Repeated retrieval against the same corpus would not manufacture one.

An evidence set could close with status insufficient, name the attempted scope and gaps, and record which future corpus change should reopen it. Search did not keep suggesting identical queries, and generation remained unavailable for archive claims.

The artifact documented a negative result without pretending absence of evidence proved the opposite claim.