Skip to Content
V1GovernanceSession capture

Session capture

Session capture lets an org collect what its members do with AI tools, so Lore can later turn it into shared org memory. It is off by default: nothing is captured until an org owner turns it on and acknowledges the org’s responsibility for the data.

What is captured

  • Harnesses: Claude Code, Codex CLI and GitHub Copilot (Copilot CLI and VS Code’s “Copilot” session target, captured as one harness, copilot). Other tools are added once their capture events are verified. The org can limit capture to some harnesses.
  • Copilot: trusted folders. Lore’s Copilot hooks live in ~/.copilot/hooks/lore.json. Copilot runs a repository’s own hooks only in a trusted folder, but Lore’s user-level hooks run everywhere.
  • Codex: approve the hooks. Codex runs no hook until you approve it in /hooks (project hooks also need a trusted folder). lore hooks install reminds you, and lore hooks status says when Codex’s hooks are installed but have never run.
  • What: the turns of each session (your messages and the AI’s answers), from the tool’s own transcript on your machine, only for the projects the org includes (matched against the git remote).
  • When: at the end of each turn and when the session ends, by lore hook capture. A background lore sync uploads what was captured.

Redaction happens on your machine

Before anything is written to the local spool or uploaded, lore removes secrets with gitleaks’ rules and Lore’s own rule pack, plus any rules your org adds. Nothing unredacted leaves your machine.

Retention and who can see what

MemberOrg owner
The org’s capture policyyesyes, and edits it
Their own capturesyesyes
Other members’ capturesnoyes, with upload IPs
Delete capturesown ones, if the org allows itany
The text of org redaction rulesonly how many there areyes

Raw captures are kept for the org’s retention (7 to 30 days, 14 by default) and then deleted automatically.

The org’s responsibility

Your organization decides to capture and is the controller of its members’ data. It must have a legal basis for capture, for example under the LGPD, and inform its members. Lore provides the mechanisms: org-level opt-in, redaction on the member’s machine, bounded retention and visibility. If the org turns on distillation, captures are turned into memory records on the member’s machine, by the org’s own AI tool and under the org’s contract with its vendor, and wait for the org’s review unless it chooses otherwise.

To turn capture on, the org owner must acknowledge this statement in the painel. Every member sees who acknowledged it and when.

Storage for captures

Captures count against your org’s storage plan, in a capture reserve: a slice of the plan’s storage set aside for captures and the memory candidates distilled from them. Namespaces and org memory can’t use it, and captures can’t use theirs.

  • When the owner first turns capture on, the reserve defaults to 20% of the plan’s storage, or less if namespaces already take more. The owner can change it in the capture policy, as long as it fits next to the namespaces.
  • The Captures page shows how much of the reserve is used, with a warning at 90%.
  • When the reserve is full, new captures are refused but nothing is deleted. Captures wait in the spool on each member’s machine, lore hooks status says “capture storage full”, and uploads resume once retention frees space or the owner raises the reserve.

See Storage and Allowances for the whole storage pool.

Enabling capture (org owner)

  1. In the painel, open your org’s Captures page.
  2. Under Edit capture policy, choose the projects (globs such as dev.azure.com/acme/*), the harnesses, the retention, any extra redaction rules, and whether members may delete their own captures.
  3. Turn capture on, tick the acknowledgement, and save.

Members whose hooks are installed start capturing on their next session. The capture hooks are added by lore hooks install once the org’s policy is on.

Seeing your captures (every member)

In the painel, the org’s Captures page shows the policy and your own captures, turn by turn. From a terminal:

lore captures policy --org <your-org> # the policy and the statement lore captures ls --org <your-org> # your capture batches lore captures show <id> --org <your-org>

lore hooks status tells you whether each of your orgs captures, and prints a one-time notice whenever an org’s policy changes.

From captures to org memory (distillation)

Distillation turns captures into short, atomic memory records: decisions and their reasons, non-obvious facts about the org’s systems, corrections and procedures that worked. It is off until the org owner turns it on.

Where it runs. On each member’s machine, after their captures are uploaded: lore sync runs the harness the org chose, headless, to read the capture and propose records:

  • Claude Code: claude -p, with no tools, no MCP servers and no project settings.
  • Codex CLI: codex exec --ephemeral --ignore-user-config -s read-only, with no saved session, no user hooks or MCP servers, and a read-only sandbox in an empty folder. Leave the model empty to use Codex’s default.

GitHub Copilot can’t distill: its headless mode runs your hooks and keeps the session. Copilot captures are distilled by the harness the org chose, like any other, so an org that only uses Copilot can capture but not distill.

There is no API key to create: the harness signs in as it always does, and Lore never reads or holds its credentials. Lore’s own hooks do nothing inside the call, so a distillation is never captured itself.

Prerequisite for IT. Distillation uses the member’s seat in the chosen harness, so it must be signed in to the org’s account, not a personal one. For Claude Code, enforce it with the managed setting forceLoginOrgUUID. For Codex, set forced_login_method = "chatgpt" and forced_chatgpt_workspace_id in its managed configuration. Both are deployed through MDM, like the managed hooks.

What the org decides. On the Captures page, the owner sets:

  • which categories to keep and which to discard;
  • blocked terms: names, domains, codenames, or anything else that must never appear in a record (clients, partners, internal projects). They go into the prompt, which tells the model to mention neither the terms nor details that identify what they refer to, and a filter on the member’s machine and again on the Registry drops any record that names one. Every member’s machine needs this list, so members can read it;
  • the model, how many records per call, and how many existing records are shown to the model to avoid duplicates;
  • a monthly cap of input characters per member;
  • review: by default, every record waits for the owner on the Memory Review page. “Store directly” is refused while the org requires approval.

What a member sees. Each capture batch on the Captures page lists the candidates distilled from it and their state. A member can discard their own pending candidates: before review they are still their capture, not org memory. Deleting a capture also discards its pending candidates.

Approved records become ordinary org memory, with the captured member as author and the harness as platform, tagged source:capture. Each one keeps its category and the project it was captured in. When approving, the owner can correct the category. Only distilled records carry that tag, so From captures on the Memory page (or lore_memory_list with that tag) shows exactly them. Approved records stay when their capture expires.

The Memory Review page also shows, per category, how many records the owner approved and rejected in the last 30 days. A category that is mostly rejected is one to drop from the policy.

Status on your machine. lore hooks status shows, per org, the distillation harness and version, how many deltas are queued, and this month’s input against the cap. lore captures ls shows each delta’s distillation state. Deltas wait about 10 minutes for the session to settle, then the turns of a session are distilled together. A delta without anything you typed is skipped without a call.

Turning distillation on requires acknowledging version 2 of the responsibility statement. Capture keeps working while the acknowledgement is outdated; distillation waits for it.

Reading org memory

Every record has an optional category, shown in the panel with a plain label:

CategoryLabelWhat it holds
proceduresHow tosteps that worked
correctionsPitfallswhat looked right but was wrong
decisionsDecisionswhat was chosen and why
system-factsFactshow the org’s systems actually behave

Records distilled from captures also carry their project: the repository they were captured in. The Memory page has three views:

  • Browse (default): records grouped by project, then by category, with their full content. Filter by project, category or source; every filtered view has its own URL.
  • Project page: everything the org knows about one repository, by category. A good first read for someone joining the project.
  • Overview: a project × category matrix of counts, and what was added or updated per category in the last 7 and 30 days. It never counts or ranks people.

The wikilink graph moved to the Graph tab. Records distilled from captures don’t link to each other yet, so the graph shows few edges.

AI tools can use the same classification: lore_memory_store accepts an optional category and project, and lore_memory_list and lore_memory_search filter by them (category: none lists unclassified records).

Records stored before categories existed have none. The org owner can backfill them once with lore memory reclassify, which runs on the owner’s machine like distillation.

© 2025 Lore · Built by M1 Cloud