Provenance-Coupled Work: Join the Conversation to the Work, Don't Archive It Beside

Neither the AI conversation nor the artefact is the work record — the joined pair is, because each makes the other interpretable. The value is multiplicative, not additive. Capture the link when the tool call happens, or you will not get it back.

Scott Farrell · LeverageAI · July 2026 · Deliverable 190 · Full-length companion to The Deliberation Is Source

You can already archive AI conversations. You can already version documents. Those two capabilities sitting side by side do not give you a work record. They give you two silos that refuse to answer each other's questions.

The conversation alone is ethereal: was the idea used, was the recommendation accepted, was the work abandoned, which document did it apply to, did someone later reverse it? The artefact alone is equally mute: which parts were inherited, what genuinely changed, why, what alternatives were weighed, which assumptions stayed uncertain, whether the author was following policy or improvising. Placed together, the grouping changes the quality of the evidence before any interpreting model begins.

Neither the AI conversation nor the artefact is the work record — the joined pair is, because each makes the other interpretable. The value is multiplicative, not additive: not conversation PLUS document, but conversation TIMES artefact link. Because the relationship is multiplicative, the join must be made at capture time, not reconstructed later.

This article assumes you already accept that AI deliberation is worth capturing. That argument lives in the sibling piece The Deliberation Is Source. What 189 deliberately deferred — the linking problem — is what this piece owns. How do you join a session to the specific change it produced, with a typed verb that says what kind of interaction happened, in a way that also gives you the reverse path from artefact back to intent?

The answer has four load-bearing parts, and each gets real treatment below: delta-level granularity, a tiered resolver, typed outcome verbs, and the reverse index as a free by-product. Miss any one and you are back to archiving chats beside SharePoint and hoping search will invent provenance later.

The correction to the framing

The primitive needs a name.

That is the corporate generalisation of what coding agents already make obvious. Claude Code and Codex sessions run inside a working directory — a fact any user can observe from public product behaviour. That path normalises into a project key that joins the transcript to the development project before any model or embedding search runs. The relationship is provenance, not resemblance.

The Soft Join doctrine states the distinction precisely: RAG may tell you a conversation is about some code; the join can tell you that the conversation created it. That is not a higher similarity score. It is a different fact.

The W3C Provenance Data Model has been saying a related thing since 2013: provenance is information about entities, activities, and people involved in producing a piece of data or thing, used to assess quality, reliability or trustworthiness.¹ A similarity score is not that record. An exact join on a natural key is closer to what PROV means by activity and entity.

Conversation without artefact is intention without consequence. Artefact without conversation is consequence without interpretation. Together they form something much closer to a complete work episode.

Why now: the gateway decision you are making by default

McKinsey's 2025 State of AI survey found that nearly two-thirds of organisations have not yet begun scaling AI across the enterprise; roughly one-third report that scaling has begun.² That is not a reason to wait. It is the reason the capture schema is being decided under pressure, mostly without anyone treating join keys as a first-class design choice.

Corporate AI gateways are being procured right now to broker access to coding and chat tools. OpenTelemetry's GenAI semantic conventions already standardise how model interactions are traced — model parameters, token usage, and, when opted in, prompts and completions.³ Observability platforms and gateways treat tool and agent calls as first-class spans; attributes such as operation name let you see tool flows inside the same trace fabric as the model call.⁴⁵

That wave of standardisation is good news with a hole in it. Capturing tool-call resource identifiers — the file path, document ID, ticket ID, URL the tool actually touched — is nearly free at session time. Reconstructing those identifiers retrospectively, once the session is gone, is nearly impossible. Gateway products already log tool invocations at the control plane; the open design choice is whether the resource keys inside those invocations are retained as join foreign keys or discarded as noise.⁶

This is a decision being made right now, by default, mostly without anyone deciding it on purpose. If your RFP does not require resource-identifier retention, you will get token logs and lose the join.

1. Delta-level granularity: join the change, not the document

The refinement that does most of the work is deceptively simple: you do not want to join a conversation to a document. You want to join it to the document version or change set.

A Word file may have existed for six years and had two paragraphs changed yesterday. A workbook may hold forty sheets and ten years of inherited formulas while this session changed one assumption table. “Session S is related to document D” is nearly useless. “Session S modified document D version 14” is a fact.

AI session
    └── produced / modified
          └── artefact version or delta

NOT merely:

AI session
    └── vaguely related to
          └── entire document

For different work surfaces, the granular key already exists in the identity system the software left behind:

These names — SharePoint, Excel, PowerPoint, Jira, ServiceNow, Teams, Slack — appear here only as examples of systems that already mint addressable identities. The claim is not about how any of them behaves internally. The claim is that every work surface already left an identity system lying around, and the Soft Join inventory rule is to find that system before you reach for embeddings.

Delta grain is what makes typed verbs meaningful. “Modified the forecast workbook” without a version is theatre. “Modified Forecast.xlsx v31→v32, sheet Forecast, range G14:G29” is an edge you can reverse-walk later.

Concretely, a delta-level join key is a small structure, not a vibe:

Join target (delta grain)
├── surface_class: spreadsheet | document | code | ticket | ...
├── artefact_id:   stable container identity (e.g. FIN-27, SP-9102)
├── version_from / version_to
├── sub_address:   sheet/range, slide IDs, path, paragraph anchors
└── evidence:      tool_call_id, resolver_tier, captured_at

Three instances: (A) update_range(workbook=FIN-27, sheet=Forecast, range=G14:G29) joins to FIN-27 v31→v32 at that range — not to every sheet in a forty-sheet workbook. (B) Board Update.docx write returning document_id + version joins to SP-9102 v8→v9 — the home of the phrase “recoverable delay.” (C) A coding-agent patch under a working directory joins to repo + commit + path. What is not a join key: a topic label, a project name alone, or a similarity score. Those may be facets. They do not pin a version.

2. The tiered resolver: keys, then graph, then similarity

Most future joins can be deterministic. Tool calls emit foreign keys as a by-product of doing the work:

read_file(document_id=SP-4831, version=12)
update_range(workbook=FIN-27, sheet=Forecast, range=G14:G29)
create_document(folder=Project-Orion, id=SP-6182)
send_email(thread_id=18c4..., attachment=SP-6182-v3)

The Soft Join operating rule is: keys first, graph second, similarity for the unresolved remainder. A practical resolver implements that rule as tiers:

1. Exact. The AI tool called the artefact directly by ID or absolute path. Lowest ambiguity.
2. Strong structural. Same project key, user, folder tree and time window; no exact resource ID but the structural envelope is tight.
3. Version correlation. The file changed during the session window and appears in tool events (even if only by relative name).
4. Content fingerprint. Output text, table, or code hunk from the session appears in the new artefact version.
5. Semantic candidate. Conversation and artefact appear related by embedding or lexical similarity — pending human or policy confirmation. Never auto-promoted to a hard fact.
6. Unknown. Preserve the conversation without inventing a relationship.

Data-lineage practice outside knowledge work is converging on the same pressure: when AI systems generate insights or decisions, lineage that shows which data contributed and how it was transformed is treated as a trust layer, not a nice-to-have.⁷ The resolver is knowledge-work lineage for tool-using sessions.

Proof burden: one real estate, honest numbers

The strong estate this doctrine already runs on is a coding archive: Claude Code and Codex sessions joined to projects via working-directory natural keys, with tool events carrying paths into the repository. That is provenance, not resemblance — any user can see the session operating inside a project directory.

Hit rates by tier on that estate have not been published as measured percentages in the source material for this piece. Fabricating precise-looking tier percentages would be worse than leaving the blank, because readers remember invented precision as fact. What can be stated as shape, not measurement:

The test that would settle the blank: take one named coding estate (or one document estate with instrumented tool calls), sample every tool-call resource reference over a fixed window, classify the highest tier that resolves it, and report counts by tier plus unresolved remainder. Until that measurement exists, the doctrine is implementable and the rates are open. A semantic-only baseline on the same corpus would show how much pure similarity would invent or miss — that comparison is also not yet measured in the source material, and is listed as the right experiment rather than a fake result.

Work one cascade without inventing rates. Session S104 emits update_range(workbook=FIN-27, sheet=Forecast, range=G14:G29) with no version in the args. Tier 1 finds artefact FIN-27. Tier 2 confirms uniqueness in the project/time envelope. Tier 3 pins v31→v32 from the version store intersecting the session window. Tier 4 may fingerprint the written cells. Tiers 5–6 unused. Change the scenario so two Forecast.xlsx files exist and both changed: uniqueness fails; honesty exits at unknown or human-confirmed semantic candidate — it does not pick a file to satisfy a dashboard.

3. Typed outcome verbs: read is not modified

A join without a verb is still ambiguous. The resolver must distinguish what kind of interaction happened, because the correct interpretation of the joined pair depends on which verb applies.

At minimum:

• created
• modified
• read
• cited
• reviewed
• rejected
• superseded
• attached-to
• informed-by
• possibly-related-to (soft remainder only)

Here is the worked case where the verb changes the interpretation.

Without verbs you over-credit speculative chat that only browsed a file, and under-credit sessions that changed one cell after a long investigation. Typed verbs are how Bundle-Epistemics applies to a work episode: the closed unit is not “session near document,” it is person, intent, inputs opened, tool actions, artefact before/after, semantic change, rationale, and outcome state — with each tool action carrying a verb.

Three wrong institutional moves make the verb operational. (1) Treat every touch as authorship — consult sessions appear as co-authors of the model. (2) “Fix” hand-pasted numbers by upgrading every chat that mentions the filename to modified — theatre. Prefer informed-by or a capture-gap label. (3) Collapse rejected options into silence — put rejections in the Cognitive Commit even when no file edge exists. If your system cannot distinguish Interpretation A from B on S104, stop adding features and fix verb emission first.

4. The reverse index as a free by-product

Conversation → artefact is easier during the session: the tool log says exactly what was opened or changed. Artefact → conversation feels hard later because the relationship is usually not written into the file.

That asymmetry is an index problem, not a capture problem. Once you capture the forward relationship:

session S104 --modified--> document D88 version 14

you deterministically have:

document D88 version 14 <--modified-by-- session S104

The document does not need to be physically altered. The relationship lives in the organisational graph.

Worked traversal: starting from a document nobody remembers

Walk this forward and back in full — not as a summary.

Start state. A later worker opens Board Update.docx. Nobody on the team remembers who wrote the phrase “recoverable delay,” or whether Finance agreed, or why Wave 2 slipped. The document history shows v9, author “service account,” timestamp last Tuesday. That is the usual dead end.

Step 1 — resolve to version, not blob. The reverse index is keyed at version grain: Board Update.docx v9, not “the board pack.” Document-level search would return every session that ever touched any board pack. Version grain returns the sessions that produced or modified this revision.

Step 2 — reverse edges for v9. Graph returns: S104 --modified--> Board Update.docx v8→v9 with verb modified, and also S104 --modified--> Forecast.xlsx v31→v32, and S104 --read--> Vendor email thread 8842, and S104 --read--> Steering Committee Notes 24 July.

Step 3 — open the Cognitive Commit for S104. Compact join record (not a replacement for bronze):

Cognitive Commit: CC-20260727-1842
Intent: Revise FY27 delivery forecast after the vendor delay.
Artefacts read: Forecast.xlsx v31; Vendor email thread 8842; Steering notes 24 July
Artefacts changed: Forecast.xlsx v31→v32; Board Update.docx v8→v9
Semantic changes:
  - Delayed Wave 2 revenue recognition by one quarter
  - Increased contractor cost assumption by 8%
  - Replaced “on track” with “recoverable delay”
Why: Vendor mobilisation date is no longer consistent with the approved baseline.
Rejected: Compressing testing by four weeks; holding original revenue forecast with a risk footnote.
Open: Finance has not approved the contractor-rate assumption.
Status: Draft; awaiting Finance review.

Step 4 — two bronze paths off the claim. Double-Click Provenance already runs claim → semantic record → openable bronze. The new shape here is that one claim now has two bronze legs:

• Artefact bronze: open Forecast.xlsx v32 and Board Update.docx v9 — what materialised.
• Deliberation bronze: open session S104 transcript — why, including rejected alternatives and the open Finance question.

Step 5 — interpretation that neither silo allowed. The worker now knows: the phrase is not inherited fluff; it is a deliberate replacement for “on track”; the number change and the language change are one episode; Finance has not approved the contractor-rate assumption; two options were rejected with reasons. None of that is in the polished board file alone. None of it is trustworthy from an unjoined chat archive alone.

Step 6 — pin the phrase itself. The entire walk exists so one phrase — “recoverable delay” — stops being gossip. In artefact bronze, diff v8 to v9 and locate the sentence. In the Cognitive Commit, match the semantic-change bullet that names the replacement. In deliberation bronze, find the turn where the worker accepted that wording over “on track” and over a risk-footnote alternative. Three exhibits, one phrase, no hallway reconstruction. If any of the three is missing, label the gap rather than smoothing it over in the next steering pack.

This is also where multiplicative value becomes tactile. Conversation alone could contain the words “recoverable delay” in a brainstorm that never shipped. Artefact alone could contain the words via a paste from another engagement. Only the join proves this conversation produced this delta. Times, not plus.

Where the walk fails maps cleanly to miss classes you can pre-mortem in a pilot. Empty reverse index on a known AI-authored version: capture miss (resource IDs never retained). Crowded reverse index at document grain: grain miss (blob-level edges). Authorship dispute after a consult-only session appears: verb miss. Fluent Cognitive Commit with a dead session pointer: bronze miss. Fix the miss class you actually have; do not buy another enterprise search product to paper over a missing foreign key.

That reverse walk is what you get free once forward capture is correct. It is also what you cannot reconstruct six months later if the gateway never stored resource IDs.

What the reverse index makes possible

Once conversations are joined to artefacts at delta grain with typed verbs, the free reverse index supports:

• Origin recovery — “Why was this section changed?” walks to session intent, not to a guess.
• Authorship vs consultation — filter reverse edges by verb so “everyone who read this” does not look like “everyone who wrote this.”
• Inherited-content forensics — versions with no modifying session edge are more likely inherited or hand-edited outside the AI surface; versions with a modifying edge open the deliberation.
• Better ingestion — ingest work episodes, not two unrelated corpora; the ingest agent sees purpose, files consulted, before/after, dialogue, and status.
• Preventing over-credit — a brilliant idea never embodied remains proposal, not organisational fact.
• Preventing under-credit — a small final change can point back to a long investigation that established why obvious options were wrong.

What this piece does not own is the management read of the aggregate of these joined episodes — weekly cognitive-state views, portfolio friction maps, capacity hypotheses. That belongs to a separate forthcoming piece. Name it as future work; do not invent a URL for it.

Three reverse-index questions on one artefact make the free by-product concrete. Forecast.xlsx v32 has edges: S104 modified, S091 read, S077 modified (earlier transition), S110 possibly-related-to (unconfirmed). Who authored v32? Filter modified intersecting 31→32 → S104 only. Who depended without changing? Filter read → includes S091 (notify list when superseded). Unexplained drift? A v33 with no modifying session from an approved surface returns empty — hand edit, capture miss, or off-platform tool. Empty is information. Do not fill it with a tier-5 hallucination. Without verbs and version grain, all four sessions collapse into one noisy neighbourhood and none of the questions stays crisp.

The closed unit and the Cognitive Commit

The knowledge unit is not either side. It is a work episode:

Work episode
├── Person and AI session
├── Parent intent
├── Inputs opened
├── Tool actions performed (typed verbs)
├── Artefact before
├── Artefact after
├── Semantic change
├── Rationale and rejected alternatives
├── Tests or review performed
└── Current outcome state

This is Bundle-Epistemics applied to a bundle most organisations have never assembled: grouping changes the epistemic quality of the evidence before the model thinks. The Cognitive Commit is the compact semantic join between raw conversation and artefact versions — gold that routes to two bronze paths, not a third silo that replaces them.

Read the filled commit as an encoding of the four contributions, not as a pretty template. Artefacts changed lines are delta keys: Forecast.xlsx v31→v32 and Board Update.docx v8→v9 — not bare filenames. Artefacts read lines are still versioned, so consultation is not confused with the latest blob. Semantic changes are the human-readable face of the delta; they are not a substitute for version pointers. Status and open fields stop the commit from laundering a draft into canon. “Artefacts read” versus “Artefacts changed” is already a verb split — systems that dump every touched path under a single “Related files” heading undo typed verbs inside the gold layer.

The commit must not replace the raw conversation or the artefacts. Those remain bronze. If a team starts editing commits as if they were the only truth, they reintroduce the polished-file problem one layer up. Keep bronze. Point at it. Auto-generating Cognitive Commits with a model and discarding session bronze is how you get fluent fiction with footnotes.

Architecture sketch:

Raw AI conversation       Artefact versions
          \                  /
           \                /
            Cognitive Commit
                   |
             Engagement World
                   |
        Governed organisational canon

Do not archive the conversation beside the work

You have reached something stronger than “collect AI chat logs.”

Its value is not:

conversation value + document value

It is:

conversation × artefact link

because each makes the other interpretable. Zero on either side zeros the product. That is why capture-time join is not an optimisation — it is the difference between a work record and two archives that cannot speak.

Additive investment feels responsible: more chat retention, more document versions, more copilots. Multiplicative investment feels narrower: retain the resource ID on the tool call; emit the typed edge; keep both bronze paths openable. Narrow is correct. The factor you are missing is the link. Organisations can spend heavily on both limbs and still hold zero work records if the link was never captured. Article 189 established that deliberation is worth retaining as source; this piece establishes that source without a join is still not a work record. Read them as a pair.

Assemble the four contributions as one machine, not four sticky notes. Delta grain chooses the address. The tiered resolver binds tool-call resources to that address (keys, then graph, then similarity, then unknown). Typed verbs say what kind of binding it was. The reverse index falls out of the forward edges so artefact→sessions is free. Remove any part and the Chapter 12 walk fails in a different way: blob grain → popularity contest; similarity-first → guessed identities; untyped edges → authorship smears; no reverse materialisation → forward facts humans cannot walk from the file outward.

In the coding estate the path became natural: concept → project → session → decision → command → test → code. In a corporate knowledge environment the equivalent path is: organisational concept → engagement → worker session → rationale → document delta → approval → business outcome.

Do not archive the conversation beside the work. Join the conversation to the work.

Or the stronger product statement: the future corporate knowledge unit is not the document. It is the document together with the deliberation that made it — joined at the delta, typed by the verb, reverse-indexed for free, captured when the tool call still knows what it touched.

Why times, not plus, one last time: interpretability is a relation. Adding chat tokens does not create the pointer from session to version. Adding file versions does not create the pointer from version to intent. The relation is the missing factor. Zero on either side zeros the product. That is harsher than “better together,” and it is meant to be. It tells platform teams where to spend the next engineering week — not on another summariser, on resource identifiers and typed edges.

Monday action, one clause: require every approved AI surface and every corporate AI gateway to retain tool-call resource identifiers at session time, resolve them through a keys-first tiered resolver, emit typed edges into a graph that does not require mutating the artefact, and keep bronze session plus bronze version openable under Double-Click Provenance. Measure tier hit rates on your estate within two weeks; do not invent them beforehand. Minimum fields per tool call: session_id, principal, timestamps, tool_name, operation_class, resource_raw, resource_version if present, working_directory/project_key when available. Tokens without resource_raw are observability without joinability.

A short checklist, not a programme office: list every approved AI surface and gateway; for each, mark whether resource identifiers are retained today (yes/no/unknown); paste retention into RFPs and platform standards; stand the six-tier resolver on one estate first (coding estate is fine); emit typed edges into a graph without requiring artefact mutation; emit Cognitive Commits for substantial episodes; keep both bronze limbs openable; schedule the honesty-table measurement within two weeks of first production traffic; pick one forgotten document and perform the reverse walk, recording which miss class breaks it. Attach the measurement task to the same change request as the gateway config. Otherwise config ships, a slide says “full lineage,” and nobody counts unresolved remainder. Counting is install. Until numbers exist, publish the honesty table with explicit not-measured cells — never fill them for theatre.

For the why of capturing deliberation at all, read The Deliberation Is Source. For neighbouring doctrine on grounding, redundancy, novelty, inbound edges, derivational provenance, gold addressing reality, and the AI partner as challenger, the live series continues at articles 182–188. This piece owns the join. A forthcoming companion may own the management read of the aggregate of joined episodes — name it in prose if you must; do not invent a URL for it.