Here is the competent comfort that kills the problem before anyone examines it.

It sounds like an integration project. It sounds like something search will eventually fix. It sounds optional compared with “getting AI adopted.” It is none of those things. Archiving chats beside documents gives you two silos that refuse to answer each other’s questions. The conversation cannot tell you which version of which file absorbed the recommendation. The file cannot tell you which alternatives died, which assumptions stayed open, or whether the change was accepted or merely drafted.

The thesis this book holds

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.

Conversation × artefact link — zero on either side zeros the product.

That sentence is the spine. Everything that follows is how to make the product non-zero on purpose: join to the change, not the blob; resolve tool-call resources through a keys-first tier ladder; type the edge with a verb; keep the reverse index free; and refuse gateway defaults that drop resource identifiers because nobody asked for them.

What this book assumes and what it owns

This book assumes you already accept that AI deliberation is worth capturing at all. That argument is not restated here. It is the job of the primary sibling, The Deliberation Is Source, which established deliberation as upstream source for knowledge work and explicitly deferred the linking problem. Your job as a reader of this book is the linking problem. Your job as an implementer is to leave the organisation with join edges that later humans and agents can walk.

What you will be able to do after this book is concrete. Specify a tiered resolver that links sessions to artefact deltas by real keys. Distinguish at least read from modified with a worked case where the verb changes the correct interpretation. Walk reverse from a document nobody remembers to the conversational intent that changed it. Write a gateway requirement that retains tool-call resource identifiers at session time. And know which hit rates you still need to measure on your estate — without inventing them first.

Map of the book

Part I installs the joined-record worldview: neither side alone, the work-episode bundle as a Bundle-Epistemics application, natural keys as provenance rather than resemblance, and delta-level grain as the refinement that does most of the work. Part II specifies mechanism: the six-tier resolver, typed outcome verbs, the Cognitive Commit, two bronze paths off one claim, and the reverse index as a free by-product of correct forward capture. Part III pays the proof burden and the install bill: one named coding estate with an honest measurement table, a full artefact-to-intent walk, gateway urgency with a Monday checklist, and clean boundaries against the rest of the series.

Why the join is the product decision

Organisations are used to treating knowledge as piles. Pile of chats. Pile of files. Pile of tickets. Retrieval then becomes the hero technology that relates piles by similarity. That reflex is exactly what Soft Join doctrine refuses for soft data: wherever a natural key already exists, a deterministic join delivers a different kind of fact. Similarity can tell you a conversation is about a file. The join can tell you the conversation created or modified a specific version of it. Those are not the same claim wearing different confidence clothes.

Corporate AI gateways and approved agent surfaces are being designed in the same window. McKinsey’s 2025 State of AI survey found that nearly two-thirds of organisations have not yet begun scaling AI across the enterprise, while roughly one-third report that scaling has begun.¹ That is not a reason to wait for perfect governance. It is the reason capture schemas are being frozen under partial adoption — and resource identifiers for tool calls are the field most likely to be dropped as “noise” while token counts are retained as “observability.”

Argue the product, not the slogan

Why times, not plus? Because interpretability is a relation, not a pile. A conversation becomes interpretable as work when you can point at the version it changed or read. An artefact version becomes interpretable as work when you can open the deliberation that produced it. Neither property lives in either limb alone. Adding more chat tokens does not create the pointing relation. Adding more file versions does not create it either. The relation is the missing factor. In arithmetic form: if either factor is zero, the product is zero. That is a harsher claim 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 capture of resource identifiers and emission of typed edges.

Capture-time follows from the same arithmetic. The tool call is the moment the foreign key exists in the clear. After the session ends, you may still have prose and a later file. You often will not have which version was open at turn seventeen, whether a basename was unique, or which write produced which delta. Reconstruction tries to re-multiply after one factor has been discarded. Sometimes similarity guesses land. Guessing is not a work record. Chapter 6 will specify the resolver; Chapter 13 will specify the gateway clause. Hold the economics first so those chapters are not mistaken for optional polish.

The signature line

Hold one product statement through every chapter that follows.

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

Or the stronger formulation: 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 without mutating the file, captured while the tool call still knows what it touched.

Live neighbours in the series already own route-invariant grounding, wiki redundancy as error correction, novelty-preserving design, inbound edges, derivational provenance, gold that addresses reality, and the AI partner as challenger. This book links out rather than re-arguing them. It does not invent URLs for unpublished siblings. It does not self-link.

Someone tells an AI, in a corporate chat surface: “Develop a new pricing model.” The transcript is long, careful, even brilliant. Six weeks later a pricing workbook exists in the shared drive. Without a join, you do not know whether that conversation produced the workbook, informed it, was abandoned, was reversed by a later session, or is still sitting as speculative fog next to a file that came from an entirely different path.

That is the ethereal failure mode of conversation alone. It is not that the chat lacked intelligence. It is that intelligence without consequence is not a work record.

What the conversation cannot settle by itself

An AI-assisted work conversation, stored as text, leaves ordinary questions open:

• Was the idea actually used?
• Did the person accept the AI’s recommendation, or only explore it?
• Was the work abandoned mid-flight?
• Which document, ticket, or deck did it apply to?
• Did someone later reverse the outcome?

Those are not exotic audit questions. They are how a later colleague, a manager, or an ingest agent decides whether the transcript is proposal, draft, decision, or noise. Without an artefact link, the safe institutional behaviour is to treat the whole chat corpus as low-trust colour commentary. That is how organisations “capture AI” and still learn nothing from it.

What the artefact cannot settle by itself

The finished file is equally incomplete as a meaning record. A polished board pack, a forecast workbook, a policy PDF, a slide deck optimised for an audience — each answers “what is being asserted now” better than it answers “how this became true.”

• Which parts were inherited from last year?
• What was genuinely changed in this revision?
• Why was the change made?
• What alternatives were considered and rejected?
• Which assumptions remained uncertain?
• Was the author following policy or improvising under pressure?

This is the same structural split software people already know: the repository shows how things ended; the transcript preserves dated intent, rejected branches, and plans that never materialised. The corporate generalisation is not that Word files are “like code.” It is that compiled audience-facing artefacts erase derivation for the same economic reason code does: derivation is expensive to keep in the published surface.

Mutual completion

Place the two sides together and the evidence quality changes before any model is asked to judge. The conversation supplies intent and interpretation. The artefact supplies materialised outcome. Join them and you can understand what the person actually did, why they did it, and what survived into the work.

The conversation and the artefact are mutually completing evidence. The conversation explains the artefact. The artefact disciplines the conversation.

That discipline cuts both ways. The artefact prevents the conversation archive from becoming a fog of intentions, drafts, and unrealised thoughts. The conversation prevents the artefact archive from presenting every polished sentence as if it were equally original, equally considered, and equally settled.

About is not created

The Soft Join line is load-bearing here and will return when we specify the resolver. RAG may tell you a conversation is about some code — or some document, or some ticket. The join can tell you that the conversation created it, or modified a specific version of it. That is not a higher similarity score. It is a different fact.

The W3C Provenance Data Model has defined provenance, since 2013, as information about entities, activities, and people involved in producing a piece of data or thing, usable to assess quality, reliability or trustworthiness.² A cosine neighbour is not that record. An edge that says session S modified entity E at version V with verb modified is much closer to what provenance was always supposed to be.

A small scene that makes the asymmetry concrete

On Monday a worker asks an AI surface to stress-test the Wave 2 timeline against a vendor email. On Tuesday the board pack says “recoverable delay.” On Wednesday a director asks who decided that wording and whether Finance agreed. With conversation alone you can search chat for “recoverable” and hope. With artefact alone you can open version history and see a service-account author. With both unjoined you still cannot prove they are the same episode, cannot see rejected alternatives, and cannot see that the contractor-rate assumption remains open. With a joined pair you can. The rest of this book is the machinery that makes Wednesday’s question a walk rather than a rumour. The full specimen is Chapter 12. The conceptual point is already here: neither side answers Wednesday.

Why “keep more of both” fails

The incumbent fix is volume. Keep every chat. Keep every version. Buy a better search box. Volume without join multiplies ethereal text and mute files in parallel. It can even make governance worse, because the organisation now believes it “has the data” while still being unable to answer why a section changed last Tuesday.

Additive investment feels responsible. It is how budgets get approved: more storage, more retention, more copilots. Multiplicative investment feels narrower: retain the resource ID on the tool call; emit the typed edge; keep bronze openable. Narrow is correct. The factor you are missing is the link, not another terabyte of unjoined text.

The fix is not more piles. The fix is a different unit: the joined work episode. That unit is specified in the next chapter. The grain of the join — version and delta, not document-as-blob — is specified after that. Hold the mutual-completion claim first. If you do not believe that each side needs the other, the rest of the machinery will look like overhead. If you do believe it, the machinery is how you stop paying for two archives that cannot speak.

One spam email can look vaguely plausible. Hand a model three hundred similar messages as a closed branch and the judgment stops being clever; it becomes structural. Grouping changed the epistemic quality of the evidence before the model thought. That is Bundle-Epistemics: not batching for throughput, but closing the grain so patterns are obvious and junk is cheap to mark.

This book does not re-derive that framework. It applies it. The closed unit for AI-assisted knowledge work is not “a chat” and not “a file.” It is the work episode in which a person and an AI session act on real artefacts with typed actions and a material outcome state.

The closed unit

Concretely, the knowledge unit looks like this:

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

Strip any major limb and the remaining object becomes ambiguous again. Session without artefact after is intention. Artefact after without session is a mute delta. Delta without verb is a shrug about whether the session authored or merely browsed. Intent without outcome state invites the organisation to treat drafts as decisions.

Why the grouping is load-bearing

Bundle-Epistemics says the correct bundle can contain evidence that none of its isolated members contains. Applied here: the work episode contains the fact that a specific recommendation was accepted into a specific version, that two alternatives were rejected with reasons, and that one assumption remains unapproved. None of those facts lives fully in the polished file. None of them is trustworthy as organisational memory from an unjoined chat log that never names the version.

That is also why ingestion changes. Instead of ingesting two unrelated corpora — all AI conversations; all corporate documents — you ingest work episodes. The ingest agent can see the person’s stated purpose, the files actually consulted, the before/after change, the dialogue that produced the change, the status of the result, and whether it entered an approved artefact. That dramatically improves what the agent can determine about originality, material change, decision status, residual uncertainty, and reusable learning.

Over-credit and under-credit

Wrong grain produces two symmetric institutional failures.

Over-credit. A brilliant idea discussed with AI but never embodied remains a proposal or thought. If you treat unjoined chat as organisational knowledge, you will promote speculation into canon. The artefact limb of the bundle is the discipline that prevents that. No materialised delta, no implemented fact — however eloquent the transcript.

Under-credit. A small final change can point back to a long, valuable investigation that established why the obvious options were wrong. If you keep only the polished paragraph, you erase the expensive cognition. The deliberation limb of the bundle is how invisible work stays legible without forcing every board pack to include a research appendix nobody will read.

Semantic closure, applied not re-argued

Semantic closure is the parent move: the smallest deterministic bundle whose meaning closes, reconstructed from the medium’s own structure rather than from a fixed-size chunk. Email needs the thread. Notes need the tree. Spam needs the cluster. AI-assisted work needs the episode: session identity, tool actions, and artefact versions that the tools actually touched.

The practical implication for architecture is boring in the way good ETL is boring. Put engineering effort into deterministic assembly of the episode before generative judgment. Identify natural keys and structural glue. Materialise the closed bundle. Ask for significance against the bundle. Write results with pointers back to bronze members. That pipeline is how you stop paying frontier-model prices to rediscover that a chat and a file were never joined.

Episode assembly is boring on purpose

Practically, assembling a work episode looks like ETL, not like a clever prompt. From the session log take identity, timestamps, and tool events. From the version store take artefact before/after for every write. From the deliberation take intent sentences, rejected options, and open questions — preferably into a Cognitive Commit rather than leaving them only in raw turns. From policy take status: draft, awaiting review, approved, abandoned. Bind them with the join edges Chapters 5–7 will specify. The model’s job, if any, is to help phrase semantic-change bullets against that already-closed bundle — not to invent which file was touched.

Teams that skip assembly and ask a model “what did we decide this week?” over a chat export are repeating the spam-singleton mistake at enterprise scale. The pattern is not in the atom. The pattern is in the closed episode. Bundle-Epistemics predicted this; the work-episode bundle is where the prediction lands for AI-assisted knowledge work.

What this chapter deliberately does not finish

The work episode names tool actions and artefact before/after. It does not yet specify how tool-call resource references resolve to real-world artefact versions, how verbs are typed, or how reverse navigation works. Those are the next chapters. The point here is narrower and prior: if your unit of knowledge is still “document” or “conversation,” you are arguing about join technology on the wrong grain. Change the unit first. Then the resolver has something worth resolving.

Grouping is not an optimisation pass. It is an epistemic pass. Close the work episode so consequence and interpretation become co-visible.

The strong case is already visible in public coding-agent behaviour. Claude Code and Codex sessions run inside a working directory. Any user can observe that the agent operates on files under a project path. That path — or an encoded form of it — is a natural key. Normalise it into a project key and you join the transcript to the development project before any model or embedding search runs. The relationship is provenance: this session operated on this project. It is not a claim that the words in the chat merely resemble the words in the repository.

That claim is load-bearing for this book, and it is argued outside-in. No insider knowledge of product internals is required. What matters is what any practitioner can see: sessions have a workspace; tool events name paths; paths belong to projects. Those are enough to mint a join key the organisation did not have to invent.

What Soft Join already settled

The Soft Join doctrine was built on exactly this refusal of the lazy substrate. The industry’s default way to relate two soft-data corpora is embedding similarity — probabilistic, fuzzy, “these feel related.” But wherever a natural key already exists — a dev folder name, an email subject, a CRM record ID — a deterministic join is exact and free. RAG may tell you two conversations are about this code. The join can tell you they created it.

Soft Join’s later chapters inventory the keys organisations already have and state the operating rule this book reuses rather than re-derives: keys first, graph second, similarity for the unresolved remainder.

Soft Join also deferred something explicitly: once conversations are joined to code, a second story opens about what the join found — and that story deserved its own treatment. This book is that deferred treatment for the corporate work-episode join, with four additions the parent does not own: delta-level granularity, a tiered resolver for tool-call resources, typed outcome verbs, and the reverse index as a free by-product.

The natural-key inventory (corporate)

Before you embed a single conversation against a document store, inventory the identity systems the software already left lying around. Soft Join listed the treasure hunt. This book needs the same eye for AI tool surfaces:

• Folder and path names — project directories, working directories, shared-drive trees.
• Document and drive identifiers — GUIDs, item IDs, version IDs in document systems (named only as identity categories).
• Ticket and case IDs — the surrogate keys ticketing and ITSM systems were designed to join on.
• Message and thread IDs — email and chat systems already mint them.
• CRM and engagement codes — account, opportunity, engagement identifiers quoted into every serious work artefact.
• Repo, branch, commit, path — the coding estate’s native grain.

SharePoint, Excel, PowerPoint, Jira, ServiceNow, Teams, and Slack appear in this book only as examples of systems that already carry addressable identifiers. No claim is made about how any of those products behaves internally. The claim is architectural: every work surface left an identity system on the floor, and most AI capture pipelines step over it on the way to a vector database.

Certainty is free; you keep buying confidence

A join on equality is not a clever idea. It is an old relational idea pointed at soft data. What is new is the willingness to stop assuming that because the data is unstructured, every relationship in it must be probabilistic too. Organisations are riddled with keys. Certain context is the cheapest, best context there is. Most teams are paying models to approximate the free kind while the free kind sits in metadata and tool logs.

That is not a higher similarity score. It is a different fact.

External standards language points the same direction. The W3C PROV data model treats provenance as a record of entities, activities, and people involved in producing something — material for trust assessments, not for vibes.² Your Soft Join edges are how soft data starts looking like that record.

Transcript and artefact still differ

Even with a perfect project key, the conversation and the artefact remain different evidence types. Code is the what; the transcript is the why. The transcript holds dated intent, rejected alternatives, and never-built plans that the repository cannot reconstruct. The natural-key join does not collapse those types into one blob. It places them in a relation so each can discipline the other. That is the point of Provenance-Coupled Work: not fusion into mush, but a typed edge between mutually completing limbs of one work episode.

Why the Soft Join order is not optional taste

Keys first, graph second, similarity last is not a style preference. It is an error-cost ordering. A wrong exact key match is rare if inventories are clean; a wrong structural unique can happen when two files share a basename in one folder; a wrong semantic match is common whenever two workstreams share vocabulary. If you run similarity first, you spend your trust budget on the noisiest signal and then have no clean place to put the free certainty that paths and IDs already offered. Soft Join’s deferred promise — that what the join finds deserves its own article — only pays off if the join itself stayed honest. This book is that article for work episodes; it inherits the order rather than renegotiating it.

What comes next

Keys alone are not enough if you join at the wrong grain. Project-level join is already powerful for coding archives. Corporate knowledge work needs the next refinement: join to the version and change set, not to the multi-year document as an undifferentiated blob. That is the next chapter. Then the keys become inputs to a tiered resolver rather than a slogan.

A Word document might have existed for six years. A worker may have changed only two paragraphs yesterday. A spreadsheet may contain forty worksheets and ten years of inherited formulas, while the current session changed one assumption table. If your join lands on the document as a blob, every historical session that ever touched any part of that blob becomes equally “related.” The reverse index becomes a popularity contest. The forward edge becomes a rumour.

The ideal relationship is therefore not session vaguely related to entire document. It is session produced or modified a specific artefact version or delta.

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

NOT merely:

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

Why grain is not pedantry

Delta grain is what makes the rest of this book’s machinery meaningful. Typed verbs need a target: you cannot honestly say modified without saying what changed. Reverse walks need a version: “why was this section changed?” is a version question. Cognitive Commits need before/after: semantic change is a diff story. Bundle-Epistemics needs closure: the episode closes around the change set, not around a six-year container that outlived twelve strategies.

Document-level edges fail the interpretability test even when they are technically true. Yes, the session touched the forecast workbook. Which sheet? Which version? Which cells? Did it only read the baseline and write a board pack? Without grain, later readers invent answers.

Identity at useful grain

For different artefacts, the granular key is already minted by the work surface’s identity system. The table below is definitive for this book’s corporate inventory. Product names appear only as categories of systems that carry resolvable identities — not as claims about internal product behaviour.

What a delta-level join key actually looks like

Doctrine without a concrete key shape is still a slogan. Here is what the join target is, as a data structure you could store tomorrow. The point is not a universal schema language. The point is that every field below is already present somewhere in the work surface or the tool call — you are assembling, not inventing.

Join target (delta grain)
├── surface_class: "spreadsheet" | "document" | "code" | "ticket" | ...
├── artefact_id:   "FIN-27"          // stable identity of the container
├── version_from:  31                // optional for pure reads
├── version_to:    32                // required for created/modified
├── sub_address:   sheet="Forecast", range="G14:G29"
├── content_span:  optional hash or paragraph anchors for prose
└── evidence:      tool_call_id, resolver_tier, captured_at

Walk three concrete instances so the shape is not abstract.

Instance A — forecast cells. Session S104 issues update_range(workbook=FIN-27, sheet=Forecast, range=G14:G29). The join target is not “Forecast.xlsx.” It is workbook FIN-27, version 31→32, sheet Forecast, range G14:G29. A later reverse query from “why did Wave 2 revenue move?” can land on that range, not on every session that ever opened the forty-sheet file. The sub_address is load-bearing: without it, sheet Actuals and sheet Forecast collapse into one false fact.

Instance B — board language. The same session writes Board Update.docx through a document tool that returns document_id=SP-9102, version=9. The join target is SP-9102 v8→v9. If the store also exposes paragraph or revision-set IDs, attach them as content_span; if not, version grain is still far better than item-level blob. The phrase “recoverable delay” lives in that version transition. Chapter 12 will reverse-walk from this exact target.

Instance C — code path. A Claude Code session with working directory /home/dev/orion-api applies a patch to src/billing/mediation.py and the worker commits a1b2c3d. The join target is repo orion-api, branch main, commit a1b2c3d, path src/billing/mediation.py. The project_key from the working directory joins the session to the repo before path resolution. Path without commit is better than nothing and worse than delta grain: the file may have changed ten times since.

Notice what is not in the key: a similarity score, a topic label, a project name alone, or “related to Finance.” Those may be useful facets. They are not join keys. A join key must be resolvable to one artefact version (or a tight, evidence-backed candidate set) without asking a model whether the vibes match.

Tool calls already emit foreign keys

A corporate AI gateway or custom agent can capture many of these directly from tool calls. The calls are not abstract logging events. They are foreign-key emissions produced 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)

Read each line as a potential edge. read_file with version 12 is a read toward SP-4831@12. update_range is a modified toward FIN-27 with sub_address. create_document is a created toward a new artefact_id. send_email with attachment is often attached-to plus a secondary edge to the attachment version. If the gateway retains those resource identifiers, the resolver in the next chapter has something exact to match. If the gateway discards them and keeps only “tool X succeeded in 420ms,” you have observability without joinability. Token counts without resource keys are how organisations build AI telemetry that cannot answer a provenance question.

What delta grain forbids

Delta grain forbids three common cheats. First, attaching every session in a project to every document in the project folder and calling it linkage. Second, using filename string equality without version when the file is long-lived. Third, promoting semantic similarity between a chat and a document title into a hard modified edge. Those cheats recreate document-blob emptiness with more confidence theatre.

Bridge to the resolver

Once the target is versioned identity, resolution becomes a procedure rather than a hope. Exact tool-call IDs land in tier one. Structural envelopes and version correlation recover near-misses. Content fingerprints catch renames. Semantic candidates wait for confirmation. Unknown preserves the conversation without inventing a relationship. That ladder is Part II’s first mechanism chapter. The doctrine point here is simply: pick the right join target before you build the ladder, or every tier will climb toward the wrong object.

Join to the version or change set. The document-as-blob is almost always the wrong address.

Most future joins can be deterministic if you stop throwing away the keys. Tool calls already look like foreign-key emissions. The Soft Join operating rule — keys first, graph second, similarity for the unresolved remainder — becomes a six-tier resolver when applied to AI tool resources.

This chapter specifies the procedure at a level where a platform team could implement it next week on one estate. Hit rates by tier are deliberately not invented here; Chapter 11 states shape expectations and the measurement that would settle them.

Inputs the resolver needs

For each tool-call event in a retained session log, collect at minimum:

• Session ID, principal (person), timestamp window.
• Tool name and operation class (read, write, search, send, …).
• Resource reference as emitted: path, document ID, URL, ticket ID, workbook ID, message ID, and any version field present.
• Working directory / project key when the surface provides one.
• Optional: content hashes of written payloads; git commit SHAs; mtimes observed.

If your gateway cannot supply resource references, stop. You do not have a resolver problem yet. You have a capture problem. Fix capture first (Chapter 13).

The six tiers

Tier 1 — Exact

Match rule: the tool called the artefact directly by stable ID or absolute path that maps 1:1 to an inventory record, including version when present. Emit: hard edge with high confidence. Shape: resolves most explicit-ID and absolute-path calls; low ambiguity. Measured hit rate: not measured in source material (see Ch 11).

Tier 2 — Strong structural

Match rule: no exact resource ID, but the same project key, user, folder tree, and tight time window uniquely identify a small candidate set (ideally one). Relative paths resolve against the session working directory. Emit: hard edge only when uniqueness holds; else demote. Shape: recovers many project-scoped relative references. Measured hit rate: not measured.

Tier 3 — Version correlation

Match rule: a candidate artefact version was created or modified during the session window and the artefact appears in tool events (even by relative name or basename). Git commits, document version services, or storage mtimes supply the version spine. Emit: edge with medium confidence; attach evidence pointers. Shape: useful when clocks and version stores are trustworthy. Measured hit rate: not measured.

Tier 4 — Content fingerprint

Match rule: output text, table fragment, or code hunk from the session appears in the new artefact version (hash, normalised text match, or structured cell match). Emit: candidate or medium edge; watch collisions. Shape: catches renames and indirection; costlier. Measured hit rate: not measured.

Tier 5 — Semantic candidate

Match rule: embedding or lexical similarity suggests conversation and artefact are related, but no key or structural proof. Emit: possibly-related-to only, pending human or policy confirmation. Never auto-promote to modified or created. Measured hit rate: not measured; false-positive risk is the point of quarantine.

Tier 6 — Unknown

Match rule: no honest resolution. Emit: no artefact edge. Preserve the conversation as bronze. Do not invent a relationship to satisfy a completeness dashboard. Shape: the unresolved remainder is a first-class outcome, not a failure to hide.

Procedure (implementable)

1. Normalise session identity and project/working-directory key.
2. Extract every tool-call resource reference into a typed tuple (kind, raw, version?, op).
3. Attempt Tier 1 against the estate inventory (path index, document ID index, ticket index, …).
4. On miss, attempt Tier 2 using project key + relative resolution + time window uniqueness.
5. On miss, attempt Tier 3 using version store events intersecting the session window and tool basenames.
6. On miss, attempt Tier 4 fingerprint against versions touched in-window or produced as write payloads.
7. On miss, optionally enqueue Tier 5 semantic candidate for review; default off for automated hard edges.
8. Else Tier 6: store session, store unresolved resource raw string for later inventory improvement, emit no edge.
9. Attach the highest successful tier ID and evidence to the edge for audit.

Mapping to Soft Join ordering

Tiers 1–2 are keys. Tier 3 is graph/relationship inference over time and version stores. Tiers 4–5 are increasingly similarity-like, with tier 4 still content-exact and tier 5 fully semantic. Tier 6 is the honesty sink. That ordering is not aesthetic. It is how you stop paying a model to guess identities your tool log already knew.

Data-lineage practice outside this domain is under 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.³ The tiered resolver is knowledge-work lineage for tool-using sessions.

Worked cascade on one tool call

Suppose session S104, project_key eng-orion, emits:

update_range(
  workbook="FIN-27",
  sheet="Forecast",
  range="G14:G29"
)  // no explicit version field in the tool args

Tier 1. Look up workbook ID FIN-27 in the inventory. Found. Version field absent in the call — Tier 1 partial: artefact identity exact, version not yet pinned. Do not stop if version is required for modified edges.

Tier 2. Session principal, project folder, and time window show FIN-27 is the only Finance workbook open in eng-orion for that hour. Structural envelope supports uniqueness of the container.

Tier 3. Version store shows FIN-27 advanced 31→32 at 18:41, inside the session window; tool event basename Forecast aligns. Pin version_from=31, version_to=32. Emit candidate modified with tier=3 evidence (version correlation) plus tier=1 artefact_id.

Tier 4. Optional corroboration: cells G14:G29 in v32 fingerprint-match the payload the tool wrote. Strengthen evidence; still not a new identity.

Tier 5. Not used. We already have identity and version.

Tier 6. Not used.

Now change one fact: the tool args contain only path="Forecast.xlsx" with no workbook ID, and two Forecast.xlsx files exist in the project. Tier 1 fails. Tier 2 fails uniqueness. Tier 3 may still bind if only one of the files versioned in-window and the write payload fingerprints to it (Tier 4). If both files changed, you stop at Tier 6 or a human-confirmed Tier 5. That is the discipline: the cascade is allowed to fail. It is not allowed to pick the wrong Forecast.xlsx to satisfy a completion metric.

Hit rates for each tier on a production corpus are not measured in the source material for this book. Chapter 11 states shape expectations and the counting protocol. Do not read the worked cascade as an implied percentage.

What the resolver does not decide alone

Resolution answers which artefact version. It does not finish what kind of interaction happened. That is the job of typed outcome verbs in the next chapter. A perfect Tier 1 match on a read_file is still only a read. Promoting it to authorship because the conversation sounds decisive is how you corrupt the reverse index.

Suppose the resolver correctly links session S104 to Forecast.xlsx version 31. Congratulations: you know which object. You still do not know what the session did. Did it consult the baseline while drafting a board pack? Did it change the revenue recognition timing? Did it create a copy? Did it merely attach the file to an email? Those are different work records. Treating them as the same edge is how reverse indexes become useless popularity graphs.

The verb set

At minimum the system must distinguish the following outcome verbs. You may refine subtypes later; you may not collapse the set into “related.”

• created — the session produced a new artefact identity.
• modified — the session changed an existing artefact into a new version/delta.
• read — the session opened or fetched the artefact as input without writing it.
• cited — the session pointed at the artefact as authority without necessarily opening full content.
• reviewed — the session examined the artefact for evaluation, not authorship.
• rejected — the session explicitly discarded a candidate artefact or option (often visible only in deliberation).
• superseded — the session replaced a prior artefact version as the current candidate of record.
• attached-to — the artefact was bound to a message, ticket, or pack as payload.
• informed-by — softer than read: the artefact shaped the work without a clean open event.
• possibly-related-to — soft remainder only (resolver tier 5); not a hard provenance claim.

Where the verb comes from

Prefer the tool operation class when it is explicit: read_file → read; update_range / write_file / apply_patch → modified; create_document → created. When the tool is ambiguous, combine operation with version-store evidence: if a new version appears and the session wrote bytes that fingerprint into it, emit modified. If the session only fetched content and the version spine is unchanged, emit read. Do not upgrade to modified because the prose sounds confident.

Worked case: read versus modified

This is the proof burden that verbs earn their keep. Walk it carefully.

Same transcript text. Different institutional facts. If your system stores only “S104 related to Forecast.xlsx,” you cannot tell A from B. Every downstream consumer — human or agent — will eventually pick the wrong one under pressure.

Why agents need verbs even more than humans

Humans sometimes recover context by gossip. Agents do not. An ingest agent asked “who changed the forecast assumptions?” will happily retrieve every session that mentioned the filename if verbs are absent. That pollutes learning, over-attributes, and trains the organisation to distrust the graph. Typed verbs are how the reverse index stays a tool rather than a rumour mill.

Rejected and open still matter

Not every important verb lands on a corporate file. rejected often lives only in deliberation: compressing testing by four weeks was considered and discarded. That rejection may never produce an artefact delta, yet it is part of the work episode’s meaning. Capture it in the Cognitive Commit even when no file edge exists. Likewise, open questions (“Finance has not approved the contractor-rate assumption”) prevent status inflation. Verbs on artefacts and state on the commit work together; neither replaces the other.

Extend the worked case: three wrong institutional moves

Stay with S104 and the forecast. Three failure modes show why the verb is operational, not cosmetic.

Wrong move 1 — treat every edge as authorship. An ingest agent builds “owners of Forecast.xlsx” from all sessions that touched it. Sessions that only read the baseline to draft a risk footnote are listed as co-authors of the model. Finance escalates. Trust in the graph dies. The fix is trivial if verbs exist: filter modified and created for authorship questions; use read for consultation lineage.

Wrong move 2 — treat absence of write tools as absence of influence. A session never calls update_range but dictates numbers that a human pastes by hand. Strict tool-class verbs under-count. That is a known residual. Do not “fix” it by upgrading every chat that mentions the filename to modified. Prefer an explicit informed-by or human-confirmed edge, or accept under-count with a capture-gap label. Honesty beats theatre.

Wrong move 3 — collapse rejected options into silence. S104 rejects compressing testing. No file edge carries rejected unless you model option artefacts. Put rejections in the Cognitive Commit even when no document version changes. Verbs on files and state in the commit are complementary; file verbs alone cannot hold the graveyard of options.

The read-versus-modified contrast remains the minimum proof. If your system cannot distinguish Interpretation A from Interpretation B on S104, stop adding features and fix verb emission first.

Bridge

With delta targets and typed verbs, you can emit a compact semantic join record: the Cognitive Commit. That record is not a third archive that replaces bronze. It is the gold route that points to artefact versions and deliberation in one place. Specify it next.

The verb is not metadata decoration. It is the difference between consulted and authored.

Git made a social fact out of a technical one: a commit is a small, named packet that binds intent-ish message, change set, author, and parent history. Knowledge work under AI needs an analogous packet. Not because everything should become software theatre, but because the work episode is otherwise too large to navigate and too easy to mis-summarise.

Call the packet a Cognitive Commit. It is the compact semantic join between the AI conversation and the artefact versions that conversation read, created, or modified. It records what meaning changed and why, while pointing at authoritative artefacts and the retained bronze session.

What fields it must carry

At minimum:

• Commit ID and timestamps.
• Intent — parent purpose in the worker’s terms.
• Artefacts read — identities at version grain with verb read (or cited/reviewed).
• Artefacts changed — before→after versions with verb created or modified.
• Semantic changes — short statements of what meaning moved.
• Why — rationale that survives when the polished file erases derivation.
• Rejected — options considered and discarded.
• Open — unresolved assumptions, approvals, risks.
• Status — draft, awaiting review, approved, superseded, abandoned.
• Pointers — session bronze ID; edge list with resolver tier IDs.

Filled example (read every field)

Cognitive Commit: CC-20260727-1842

Intent:
Revise FY27 delivery forecast after the vendor delay.

Artefacts read:
- Forecast.xlsx v31
- Vendor email thread 8842
- Steering Committee 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 the original revenue forecast with a risk footnote.

Open:
Finance has not approved the contractor-rate assumption.

Status:
Draft; awaiting Finance review.

Read the fields as a unit. Intent without status would let a draft look final. Semantic changes without rejected options would hide the graveyard that often contains the real learning. Artefacts changed without version transitions would fall back to blob emptiness. Open without a named owner of the residual risk would turn uncertainty into ambient anxiety. The commit is small because it is selective, not because the work was simple.

Architecture: join surface, not third silo

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

The Cognitive Commit must not replace the raw conversation or the artefacts. Those remain bronze. The commit is gold that routes: from a claim or a search hit to the compact meaning packet, then double-click into either bronze limb. If a team starts editing commits as if they were the only truth, they will reintroduce the polished-file problem one layer up. Keep bronze. Point at it.

Relation to the Knowledge Work Commit

Article 189 develops the Knowledge Work Commit as the emission contract for deliberation-as-source. This book’s Cognitive Commit is the same family of artefact seen from the join side: emphasis on version transitions, typed artefact edges, and reverse navigability. Do not treat them as rival standards. Treat them as one compact join record with two reading frames — session-side schema and artefact-join record. Implementations should emit one packet that satisfies both frames rather than two competing logs.

What good commits prevent

They prevent over-crediting speculative chat: no changed artefacts and status still exploratory means the packet is a proposal marker, not canon. They prevent under-crediting invisible cognition: a one-line board change can carry three semantic change bullets and two rejections that justify the cost of the episode. They prevent status laundering: “awaiting Finance review” is a first-class field, not a footnote someone deletes when the deck is exported.

How the commit encodes delta grain and verbs

Look again at the filled example with the four contributions in mind. 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 the version pointers. Status and open fields stop the commit from laundering a draft into canon. If you generate commits that say “updated the forecast” without version transitions, you have reinvented document-level mush inside a prettier template.

Verbs need not always appear as English words in the commit body if the edge list is attached machine-side, but the human-readable commit should not contradict them. “Artefacts read” versus “Artefacts changed” is already a verb split. Systems that dump every touched path under a single “Related files” heading undo Chapter 7 inside the gold layer.

Bridge

Once commits exist, Double-Click Provenance gains a second bronze leg. The next chapter develops that shape: artefact evidence for what materialised, deliberation evidence for why. Then the reverse index shows how those legs become navigable from the file outward.

Gold explains where and why. Bronze proves exactly what happened. The Cognitive Commit is gold with both bronze addresses filled in.

Start with the parent pattern, already established for human-facing trust. A material claim appears in conversation or in a decision pack. Click once into a typed semantic record — a wiki page, a Cognitive Commit, a case card. Click twice into an openable bronze artefact: the email, the PDF, the transcript fragment, the database row that still exists even if the original application does not. Dignity for the person who did the work. Auditability for the enterprise. One architecture.

That path assumed, roughly, one bronze exhibit per claim. AI-assisted work breaks the assumption in a productive way. The claim now naturally forks.

The new shape

Meaning claim
├── artefact evidence: what materialised
└── deliberation evidence: why it materialised

Artefact bronze answers: what bytes, cells, paragraphs, or slides exist after the episode? Open Forecast.xlsx v32. Open Board Update.docx v9. See the materialised outcome without trusting a summary.

Deliberation bronze answers: why those bytes, what was rejected, what remained open, what the worker asked the AI to do in their own dated words? Open session S104. See the flight recorder without pretending the polished file contains it.

Both paths hang off the same Cognitive Commit (or equivalent semantic record). Neither path alone is sufficient for AI-assisted knowledge work. Artefact-only double-click recreates consequence without interpretation. Deliberation-only double-click recreates intention without consequence. The joined architecture is literally two exhibits.

Why this is new to this piece

Double-Click Provenance is not re-derived here. Soft Join, Keep the Bronze, and Idea Provenance already push toward openable evidence and attribution with receipts. What this book adds is the explicit dual-leg structure forced by the deliberation–artefact join. Once you admit the conversation is source for the why (article 189) and the join is real (this book), the trust UI cannot offer a single bronze button and call the problem solved.

Dignity and audit, still one architecture

The parent chapter argued that the same click path serves human dignity and enterprise audit. Dual bronze strengthens both. Dignity: the expert’s investigation is not laundered into anonymous machine prose or into a senior person’s deck; the deliberation exhibit remains. Audit: risk and quality functions can demand both “show me the file version” and “show me the session that produced it,” with resolver tier evidence on the edge. Verdicts from machines remain cheap. Evidence you can open remains expensive to fake — therefore useful.

Dignity for the person. Auditability for the enterprise. Now with two exhibits per material claim.

Worked dual-path: the same claim, two exhibits

Take the claim that will matter in Chapter 12: Wave 2 is a recoverable delay, not on track, because vendor mobilisation slipped relative to the approved baseline. Under single-bronze Double-Click Provenance you might open Board Update.docx v9 and stop. That exhibit proves the words exist. It does not prove why the words replaced “on track,” whether Finance agreed, or which options died.

Under two bronze paths the click sequence is longer and honest:

1. Claim appears in a decision pack or wiki card.
2. Semantic record opens Cognitive Commit CC-20260727-1842 (or an equivalent gold page) with versioned edges and status “awaiting Finance review.”
3. Artefact bronze opens Forecast.xlsx v32 (assumption cells) and Board Update.docx v9 (language). You see what materialised.
4. Deliberation bronze opens session S104. You see the worker’s dated intent, the rejection of compressing testing by four weeks, the rejection of holding the original revenue forecast with a risk footnote, and the open contractor-rate question.

Now answer four questions that a single bronze path cannot settle. Was the phrase inherited? No — v8→v9 and the commit name the replacement. Was the number change separate politics from the board language? No — same episode, same commit. Is the pack final? No — status is draft awaiting Finance. Did anyone consider the obvious aggressive options? Yes — rejected with reasons in deliberation bronze. That is not more documentation. That is a different epistemic object: a claim with two openable proofs.

Failure modes of one path only

Artefact bronze only. You get consequence without interpretation. Organisations already live here. They fight over decks because the deck is the only exhibit. AI makes this worse: service-account authors and fluent prose increase the surface area of unexplained change.

Deliberation bronze only. You get intention without consequence. This is the failure mode this book’s thesis forbids elevating to “the asset.” A brilliant session that never wrote a version is a proposal record. It may be precious learning. It is not an implemented organisational fact. Article 189 explains why the deliberation is worth capturing as source; this book refuses to let that source float free of the delta it did or did not produce. Link: The Deliberation Is Source.

Gold only, bronze deleted. You get fluent footnotes pointing at nothing. That is the worst of both worlds: confidence theatre with no exhibit. Two bronze paths assume Keep the Bronze is still policy, not nostalgia.

Operational rule

For every material claim in a decision pack that depends on AI-assisted work, require both bronze addresses when both exist. No artefact address: you may have a proposal, not an implementation claim. No deliberation address when an approved AI surface was used: you have a result without a recoverable why, which may be acceptable for legacy hand edits but should be marked as a capture miss for gateway-covered work. No path, no material claim in the pack — the parent rule still holds; it simply became two-legged.

Encode the rule in the Cognitive Commit schema, not only in review culture: every commit that lists an artefact changed must carry a resolvable pointer to session bronze; every commit that lists only artefacts read must not be promoted as authorship of those artefacts; status and open fields must remain visible when the gold card is embedded in a pack.

Bridge

Two bronze paths are navigable from the claim downward. The reverse index makes them navigable from the artefact outward: start at a forgotten document version and walk to the commit, then to both exhibits. That free by-product is the next chapter; the full specimen walk is Chapter 12.

During an AI work session, the tool log says exactly what was opened or changed. Starting from an old artefact six months later, that relationship is usually not written into the file. People experience this as a one-way door: we can push from chat to document, but we cannot pull from document to chat. They then invent heavyweight remedies — manual “source conversation” fields, forensic search, heroic knowledge managers.

Those remedies are solving the wrong problem. Once you capture the forward relationship at delta grain with a typed verb, you can deterministically build the reverse index:

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

automatically gives:

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

The document does not need to be physically altered. The relationship can live in the organisational graph. That is the entire trick. Reverse is free if forward is correct. Reverse is archaeology if forward dropped the keys.

What the reverse index makes possible

Origin recovery

A later worker asks, “Why was this section changed?” and navigates document → version → modifying session → intent → sources opened → alternatives rejected → status. Chapter 12 walks a full specimen. The capability claim here is simpler: that question becomes a graph walk instead of a rumour hunt.

Authorship versus consultation

Filter reverse edges by verb. Everyone who read the forecast is not everyone who modified it. Without verbs, reverse indexes smear responsibility and credit. With verbs, you can ask separate questions: who consulted this baseline; who changed it; who attached it to a board pack.

Inherited-content forensics

Versions with no modifying session edge from an approved AI surface are more likely inherited, hand-edited outside the instrumented path, or capture misses. That does not automatically mean fraud; it means the graph is telling you where interpretation will be thinner. Combined with article 189’s point that finished documents often contain inherited chunks, reverse-edge absence becomes a search and trust signal rather than a dead end.

Better ingestion

Ingest agents that walk reverse edges can assemble work episodes from either side. Start from a newly published version and pull the sessions that modified it. Start from a session and pull the deltas. Either way you store episodes rather than two unjoined corpora.

Over-credit and under-credit control

A brilliant unjoined chat never appears as a modifying edge on any artefact version — so it cannot silently become “how we decided.” A tiny board-language change that was expensive to earn still reverse-links to a long session — so the investigation is not erased by brevity of the final paragraph.

Worked capability: three questions from one reverse index

Suppose Forecast.xlsx v32 has reverse edges:

• S104 modified (tier 1/3) — the vendor-delay episode
• S091 read (tier 1) — a risk officer consulted the prior baseline
• S077 modified (tier 1) — earlier, unrelated assumption hygiene
• S110 possibly-related-to (tier 5, unconfirmed) — semantic candidate only

Question 1 — Who authored v32? Filter modified intersecting version 31→32. Answer: S104 (and only S104 if the version spine says so). S091 drops out because read is not modify. S077 drops out because it points at an earlier transition. S110 never counts until confirmed and re-typed.

Question 2 — Who depended on this model without changing it? Filter read / cited / reviewed. Answer includes S091. That list is who to notify if v32 is superseded — a different operational list from authors.

Question 3 — Is there unexplained drift? If v33 appears with no modifying session from an approved surface, the reverse index returns empty for that transition. That is a signal: hand edit, capture miss, or off-platform tool. Empty is information. Do not fill it with a tier-5 hallucination to avoid the awkward blank.

Those three questions are what “artefact to every conversation that touched it” makes possible when touch is typed and versioned. Without verbs and grain, all four sessions collapse into one noisy neighbourhood and none of the questions has a crisp answer.

What this index is not

It is not the management product that reads the aggregate of episodes across a portfolio — weekly cognitive-state views, friction maps, capacity hypotheses. That aggregate read is real and useful, and it is out of scope here. A forthcoming companion owns it. It may be named; it is not given a URL, because it is not published. Do not smuggle portfolio dashboards into a join book.

Graph, not file mutation

Teams sometimes propose writing session IDs into document custom properties or commit trailers everywhere. That can help as a belt-and-braces signal. It must not be the only design. Many artefacts cannot be mutated (permissions, formats, legal holds). Many mutations will be stripped by export. The organisational graph is the system of record for edges; bronze files remain systems of record for content. Keep those roles clean.

Bridge to proof

Doctrine and mechanism are now in place: multiplicative join, episode bundle, natural keys, delta grain, tiered resolver, verbs, Cognitive Commit, dual bronze, reverse index. Part III pays the proof burden honestly: implement the resolver over one named estate without inventing hit rates; walk one forgotten document all the way to intent; then install capture requirements at the gateway while the decision is still cheap.

If reverse feels hard, you are not looking at an index problem. You are looking at a capture miss from six months ago.

Minimum proof burden one: the resolver implemented — or fully specified as an implementable procedure — over one real estate, with hit rates by tier and an honest count of the unresolved remainder. This chapter meets the specification fully. It does not meet measured hit rates, because the source material for this book does not include them. That honesty is part of the proof. Precise-looking tier percentages are exactly the kind of thing a reader misremembers as measured fact. Getting this wrong would be worse than leaving the blank.

Named estate

Domain: developer workstations and archives where Claude Code and/or Codex sessions operate inside project working directories; source code and related files live in filesystem trees often backed by git; session transcripts are retained; tool events name paths relative to or absolute under those working directories.

Natural key: working directory (or encoded project path) normalised to a project_key that joins transcript to project before any embedding runs. Public, observable behaviour: the agent works in a directory; files are read and written under that tree; git commits may record path-level diffs.

Why this estate: it is the strong case already running in Soft Join doctrine and in the source turns for this piece. It is not the only estate the corporate identity table supports, but it is the one the material can defend without fabrication.

Implementable procedure on this estate

1. Inventory projects. Enumerate repository roots / project folders; assign stable project_key (canonical absolute path or repo remote+name policy).
2. Ingest sessions. For each retained agent session, extract session ID, principal, start/end timestamps, working directory → project_key.
3. Extract tool resource references. Parse tool events for paths, URLs, and git SHAs. Classify operation class: read, write/patch, list, shell, etc.
4. Normalise paths. Resolve relative paths against session working directory; reject path escape outside project policy if required.
5. Run tiers 1–6 as specified in Chapter 6 against: path index, git history (commit, path, blob), mtimes if needed, content fingerprints of write payloads.
6. Emit edges session --[verb]--> repo/path@commit_or_version with tier ID and evidence pointers.
7. Build reverse index by inverting edges; no mutation of source files required.
8. Measure using the protocol below before publishing rates.

Honesty table: hit rates by tier

Unresolved remainder: how to count it

Define the denominator as every tool-call resource reference that names or implies an artefact (exclude pure compute tools with no resource). Define unresolved as references that exit at tier 6, plus tier 5 items never confirmed. Report:

• count and % by highest tier achieved;
• unresolved count and %;
• breakdown of unresolved reasons (missing working directory, ephemeral path, external URL out of inventory, parse failure, ambiguous structural candidates).

Until that measurement is run on a named corpus with a dated window, any percentage would be fiction. This book refuses fiction.

Test that would settle the blank (≤2 weeks)

1. Pick one machine or archive with ≥30 days of retained agent sessions and corresponding git repos.
2. Export all tool-call resource references in that window.
3. Run the tier cascade with logging of first success tier.
4. Manually audit a stratified sample (e.g. 50 refs) for false exacts and false structural uniques.
5. Publish the table with corpus description, window, and sample audit notes.

Semantic-only baseline (nice-to-have experiment)

The brief lists a nice-to-have: measure how much a semantic-only baseline would get wrong on the same corpus. That comparison is also not measured in the source material. The settling experiment: for each session, take top-k embedding matches to files in the project; score precision/recall against tier 1–3 edges as ground-ish truth; report false authorship promotions. Do not ship a fake uplift percentage. Design the A/B; run it; then cite it.

What this estate already shows without percentages

Even without hit rates, the estate demonstrates qualitative proof that matters doctrinally: natural keys exist; they join before embeddings; path-bearing tool calls are foreign keys; reverse indexes can be built without mutating repos; Soft Join’s about-versus-created distinction is operational. Those are existence proofs. They are not rate proofs. Readers should leave with both: the procedure to implement, and the discipline not to fill empty cells with marketing numbers.

Mapping the four contributions onto the estate

Delta grain. Prefer path@commit (or path with blob hash) over path alone. A session that touched mediation.py five times across a day may correspond to five commits; reverse questions about a production bug want the commit that introduced the line, not every chat that mentioned the filename.

Tiered resolver. Working directory yields project_key (key). Git relationship and time windows yield version correlation (graph). Embedding sessions to files is last (similarity). Unknown remains legal when the agent ran a shell command whose file effects were not instrumented.

Typed verbs. read_file versus apply_patch / write tools map cleanly to read versus modified. Shell commands that edit files without a structured tool event are a known residual — count them in unresolved or in a separate “effects inferred” bucket after human policy, not as silent modified edges.

Reverse index. From src/billing/mediation.py@a1b2c3d list sessions that modified that commit path; open the session bronze; recover intent. That is the coding-estate twin of Amira’s board-pack walk in the next chapter.

Again: none of these mappings implies a measured hit rate. They imply that the estate is rich enough to implement and measure without waiting for a different industry.

Minimum proof burden two: one worked artefact-to-conversation traversal in real, specific detail. Not a summary. A walk.

Start state

A later worker — call her Amira — opens Board Update.docx while preparing next month’s steering pack. In the current text she finds the phrase “recoverable delay” describing Wave 2. Nobody on her team remembers who wrote it. The document properties show version 9, author field pointing at a service account used by an AI gateway, timestamp last Tuesday afternoon. The shared-drive version history lists v8 → v9 with a one-line system note: “updated.” That is the usual dead end. Gossip begins. Someone thinks Finance wrote it. Someone thinks it was always there. Someone suggests searching the chat export for “recoverable.”

Amira does not start with search-as-resemblance. She starts with version grain and the reverse index.

Step 1 — Resolve to version, not blob

The reverse index is keyed at version grain: Board Update.docx v9, not “the board pack” as a multi-year container. Document-level reverse lookup would return every session that ever touched any board pack in the engagement folder — noise. Version grain returns sessions that produced or modified this revision.

Amira’s client queries: reverse edges where target = document GUID of Board Update, version = 9. The graph is organisational; the file itself was not mutated to store session IDs.

Step 2 — Read every reverse edge for v9

The graph returns a small set, already typed:

• S104 --modified--> Board Update.docx v8→v9 (resolver tier 1 exact; tool write on document ID + version)
• S104 --modified--> Forecast.xlsx v31→v32 (tier 1; update_range on workbook FIN-27, sheet Forecast)
• S104 --read--> Vendor email thread 8842 (tier 1 message/thread IDs)
• S104 --read--> Steering Committee Notes 24 July (tier 2 strong structural: same project folder + time window + basename unique)

Stop and read the verbs. S104 did not merely visit the board pack. It modified it. It also modified the forecast in the same episode. It read vendor and steering inputs. Already the interpretation space collapses: this is not an orphan phrase; it is part of a forecast revision episode.

Step 3 — Open the Cognitive Commit (every field)

From session S104 the gold route opens CC-20260727-1842. Amira reads it field by field — not skimming for a vibe.

Cognitive Commit: CC-20260727-1842

Intent:
Revise FY27 delivery forecast after the vendor delay.

Artefacts read:
- Forecast.xlsx v31
- Vendor email thread 8842
- Steering Committee 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 the original revenue forecast with a risk footnote.

Open:
Finance has not approved the contractor-rate assumption.

Status:
Draft; awaiting Finance review.

Intent: not “wordsmith the board pack,” but revise the forecast after vendor delay. Semantic changes: three distinct moves, one of which is exactly the phrase Amira noticed. Why: mobilisation date inconsistent with baseline. Rejected: compress testing; hold original revenue with footnote. Open: Finance has not approved contractor-rate assumption. Status: draft awaiting Finance — so the polished tone of v9 must not be mistaken for final approval.

Step 4 — Two bronze paths

Artefact bronze (what materialised). Amira opens Forecast.xlsx v32 and inspects the assumption table and Wave 2 recognition timing. She opens Board Update.docx v9 and sees “recoverable delay” in place of v8’s “on track.” Bytes, not summaries.

Deliberation bronze (why). She opens session S104. She can see the worker’s dated prompts, the AI’s options, the moment testing compression was discarded, the explicit note that Finance has not signed the rate. The commit compressed this; bronze proves it.

Step 5 — Interpretation neither silo allowed

Amira can now state facts that were unavailable from the file alone or from an unjoined chat archive alone:

1. The phrase is not inherited fluff from an older pack; it is a deliberate replacement for “on track” in the v8→v9 transition.
2. The language change and the forecast number change are one work episode, not two coincidences.
3. Two options were considered and rejected with reasons; the organisation should not re-litigate them as if never examined unless new evidence appears.
4. Finance has not approved the contractor-rate assumption; status is draft. Shipping v9 language into a final board pack without that approval would be a process miss, not a prose miss.
5. Vendor thread 8842 and the 24 July notes were inputs; any challenge to the conclusion should start there, not with generic scepticism about AI.

Slow down at the phrase itself

The entire walk exists so one phrase — “recoverable delay” — stops being gossip. Pin it. In artefact bronze, diff v8 to v9 and locate the sentence. In the 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, Amira should label the gap rather than smooth it over in her steering update.

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 would have failed

If the gateway had dropped document IDs and paths, step 2 returns empty; Amira falls back to embedding search and may retrieve an earlier brainstorm that only discussed delays without modifying files. If edges were document-level without version, she might land on S088 from last quarter that also “related to” the board pack. If verbs were missing, she might treat a read-only consult session as authorship. If the Cognitive Commit existed but bronze sessions were deleted, she would have fluent gold without proof. Each miss is a different institutional failure. The full walk only works when capture, grain, verb, commit, and bronze retention co-exist.

Use the failure modes as a pre-mortem checklist when you pilot the system. Empty reverse index on a known AI-authored version: capture miss. Crowded reverse index at document grain: grain miss. Authorship dispute after a consult-only session appears: verb miss. Fluent commit with 404 on session ID: bronze miss. Fix the miss class you actually have; do not buy another search product to paper over it.

The walk is the product. Everything else is machinery that makes the walk possible.

Return to the multiplicative thesis. Conversation times artefact link. If the link is missing, the product is zero no matter how carefully you store either side. The link is made of resource identifiers emitted while tools run. Those identifiers are either retained at session time or they are gone.

Why this is urgent now

McKinsey’s 2025 State of AI survey found nearly two-thirds of organisations have not yet begun scaling AI across the enterprise; approximately one-third report scaling has begun.¹ That gap is a design window. Capture schemas, gateway RFPs, and approved-tool lists are being written under partial adoption. Defaults set now will outlive the pilot.

OpenTelemetry’s GenAI semantic conventions standardise traces, metrics, and events for model interactions — model parameters, token usage, and optionally content.⁴ Observability platforms treat tool and agent calls as first-class spans in the same fabric.⁵ AI gateways already sit as control planes that can log MCP and tool invocations end to end.⁶⁷

That wave is necessary and incomplete. Logging that a tool ran is not the same as retaining the resource reference the tool used. Token counts without document IDs, paths, ticket IDs, and version fields will not feed the tiered resolver. You will get cost dashboards and still fail Amira’s walk in Chapter 12.

Why retrospective reconstruction fails

After the session ends, you may still have chat text and a later file version. You often will not have: which version was open at turn 17; whether a path was absolute or relative to a working directory that no longer exists; which tool call produced which write; whether a basename collision pointed at file A or file B. Similarity can invent a story. It cannot mint missing foreign keys. That is why capture-time retention is load-bearing infrastructure rather than a nice-to-have compliance add-on.

Requirements language you can paste

Approved AI surfaces and corporate AI gateways SHALL:

1. Retain tool-call resource identifiers as emitted (paths, document IDs, URLs, ticket IDs, message IDs, version fields) alongside operation class and timestamps.
2. Retain session identity, principal, and working directory / project context when the surface has one.
3. Make those fields available to an organisational join pipeline (export or event stream), not only to a vendor UI.
4. Support retention policies that keep bronze sessions long enough for audit and learning — not a silent 30-day death default without an explicit organisational choice.
5. Never require mutation of destination artefacts as the only join mechanism.

Monday checklist

1. List every approved AI surface and every gateway in procurement or production.
2. For each, document whether tool-call resource identifiers are retained today (yes/no/unknown).
3. Add the requirements language above to RFPs and to internal platform standards.
4. Stand up the Chapter 6 resolver on one estate (coding estate is fine as the first).
5. Emit typed edges into a graph; build reverse index; do not mutate source files as the primary design.
6. Emit Cognitive Commits for substantial episodes; keep session and version bronze openable.
7. Schedule the Chapter 11 measurement: tier hit rates and unresolved remainder within two weeks of first production traffic.
8. Pick one forgotten document and perform the Chapter 12 walk; record where it breaks; fix capture or resolution accordingly.

On Tuesday, pre-mortem the walk. Empty reverse index on a known AI-authored version means capture miss. Crowded reverse index at document grain means grain miss. Authorship dispute after a consult-only session appears means verb miss. Fluent Cognitive Commit with a dead session pointer means bronze miss. Fix the miss class you actually have. Do not buy another enterprise search product to paper over a missing foreign key.

On the same change request as gateway config, attach the measurement task. Otherwise config ships, a slide says “full lineage,” and nobody counts unresolved remainder. Counting is install, not a later research project. Until numbers exist, publish the honesty table with explicit not-measured cells — never fill them for theatre.

What to log, field by field

When platform engineers ask “what exactly do we persist per tool call?” answer with a minimum field list, not a vibe:

• session_id, principal_id, timestamp_start/end of call
• tool_name, operation_class (read/write/create/list/send/…)
• resource_raw (path, URL, document ID, ticket ID, message ID — as emitted)
• resource_version if present in args or response
• working_directory or project_key if the surface has one
• write_payload_fingerprint optional but valuable for tier 4
• success/error, latency optional for ops but not a substitute for resource fields

If a vendor can supply tokens and latency but not resource_raw, they have not met the join requirement. Say so in procurement language. Observability without resource_raw is how you get Chapter 11’s empty measurement table forever.

Measurement is part of install

Do not declare victory when the pipeline runs. Declare victory when you can publish the honesty table with real numbers for your estate. Until then, ship the procedure and the blanks. Resist the organisational urge to fill blanks with “approximately 80%” because a slide template has a pie chart. The whole point of this book’s honesty rule is that join systems die by fake precision.

Schedule the measurement in the same change request as the gateway config. Otherwise the config ships, the slide says “full lineage,” and nobody ever counts unresolved remainder. Counting is part of the install, not a phase-two research project.

Capturing the key is nearly free at session time and nearly impossible retrospectively. Act while free is still true.

Doctrine books fail by becoming everything. This one stays liftable only if the boundaries are sharp. The join problem is large enough without swallowing the why-capture argument, the management product, or a privacy statute. Scope discipline is how later agents can retrieve this book as a kernel unit rather than as a bag of adjacent opinions.

The multiplicative thesis, restated as a closing argument

Before the inventory of what we owned, hold the economics one more time — not as a slogan, but as the reason the boundaries matter.

If value were additive, you could archive conversations in one system and documents in another, sum the benefits, and call the programme complete. Additive thinking is what produces “we keep everything” dashboards that still cannot answer why a section changed. Multiplicative thinking says the interpretable work record is a product: conversation × artefact link. Zero on either side zeros the product. A brilliant unjoined chat contributes approximately nothing to consequence. A polished unjoined file contributes approximately nothing to recoverable why. The organisation can invest heavily in both limbs and still hold zero work records if the link was never captured.

That is why this book is not a polite sequel that adds “also link them.” Linking is the difference between two cost centres and one knowledge unit. It is also why we refuse the claim that the conversation is the asset by itself: that claim sets one factor to “enough” and treats the other as optional. The thesis forbids it. Article 189 establishes that deliberation is upstream source worth retaining; this book establishes that source without a join is still not a work record. Read them as a pair, not as rivals.

What this book owned

• Provenance-Coupled Work as the joined knowledge unit.
• The multiplicative thesis: conversation × artefact link; capture-time join.
• Delta-level grain; corporate identity inventory as categories.
• Tiered resolver procedure on Soft Join ordering.
• Typed outcome verbs with a read-versus-modified worked case.
• Cognitive Commit as compact join gold.
• Two bronze paths as the extension of Double-Click Provenance.
• Reverse index as free by-product of forward capture.
• Coding-estate proof with honest not-measured rates.
• Full reverse walk from board pack to intent.
• Gateway resource-ID capture as the urgent install move.

What this book refused

Live neighbourhood (verified URLs only)

These siblings are live and may be cited exactly as given. No other leverageai article URLs were invented for this book.

• 182 — Route-Invariant Grounding
• 183 — Wiki Redundancy Is Error Correction
• 184 — The Novelty-Preserving Carve-Out
• 185 — Inbound Edges Are a Different Question
• 186 — Derivational Provenance
• 187 — Gold Addresses Reality
• 188 — Your AI Partner Is the Challenger
• 189 — The Deliberation Is Source (primary)

How the four contributions fit as one machine

Readers sometimes leave mechanism books with four sticky notes and no assembly. Assemble them explicitly.

1. Delta grain chooses the address: version and sub_address, not document blob.
2. Tiered resolver binds tool-call resource references to that address: natural key first, graph second, similarity last, unknown when honesty requires it.
3. Typed verbs say what kind of binding it was: read is not modified; modified is not possibly-related-to.
4. Reverse index falls out of the forward edges so artefact→sessions is free, enabling the Chapter 12 walk and every origin recovery after it.

Remove delta grain and the reverse index becomes a popularity contest. Remove the resolver ordering and you pay models to guess identities tool logs already knew. Remove verbs and authorship smears across every visitor. Remove reverse materialisation and you keep forward facts that humans cannot walk from the file outward. The contributions are not four essays. They are four moving parts of one join engine.

What a forthcoming management companion may own (no URL)

Once episodes exist at scale, someone will want weekly views: where friction concentrates, which assumptions stay open across engagements, how much investigation compresses into thin recommendations. That aggregate read is legitimate. It is not designed here. Designing it early tends to smuggle surveillance aesthetics into a capture standard and to pull this book off the join problem. Name the future companion in planning conversations if you must; do not invent a slug, a folder, or a live link. Unpublished means unpublished.

Takeaway contract (closing)

After this book you should be able to:

1. State the multiplicative join thesis near-verbatim and refuse conversation-alone asset claims.
2. Write a concrete delta-level join key (artefact_id, version_from/to, sub_address, evidence) for at least one surface on your estate.
3. Specify a six-tier resolver for one estate and refuse to invent its hit rates.
4. Type edges so read and modified cannot be confused, with a worked case ready for your domain.
5. Walk reverse from a forgotten version to intent using Cognitive Commit and two bronze paths.
6. Write gateway requirements that retain tool-call resource identifiers at session time.

Signature lines

Neither the AI conversation nor the artefact is the work record — the joined pair is, because each makes the other interpretable.

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

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 while the tool call still knows what it touched.

For why deliberation is source, read 189. For the join, you are done with the doctrine. Implement the resolver. Measure your estate. Keep the bronze. Make the walk work on Monday.