Coding-agent memory is useful precisely because it survives the session that created it. The same persistence becomes risky when an old deployment decision, a superseded API rule, or an instruction from another repository appears in a new task without enough context.
The problem is not that agents remember too much. The problem is that most memory systems make it difficult to answer four basic questions: where a statement came from, whether it still applies, what changed after it was recorded, and which agents received the current version.
Docmancer keeps those questions inspectable. It discovers local agent memory, retains provenance, builds revisioned Context, and reports delivery separately for each integration. This workflow shows how to audit that state before relying on it.
Start with the health and coverage view
Run the combined status check from the repository you care about:
docmancer status --project "$PWD"
Status combines local memory health, discovered source coverage, pending review, security findings, agent delivery, and optional Cloud state. It helps distinguish several failures that otherwise look identical from inside a coding session.
If a deployment decision is missing, the source may not have been discovered. If a connected agent receives no Context, the integration may be installed but its projection may be stale. If the corpus contains contradictory records, retrieval may be working correctly while the underlying knowledge still needs review.
For scripts or continuous checks, add --check:
docmancer status --project "$PWD" --check
The command exits non-zero when the local setup needs attention, which makes it useful as a preflight without turning memory quality into a hidden runtime surprise.
Inspect the evidence behind one answer
Ask a question with answer generation disabled:
docmancer ask \
"What must happen before a production deployment?" \
--project "$PWD" \
--no-answer \
--debug
This returns the local evidence bundle rather than smoothing it into prose. Debug output exposes retrieval scores and raw evidence metadata, while the normal result retains source attribution. You can see which agent wrote the record, which project it belongs to, and which source file supports it.
Project scoping matters here. Without --project, global recall can search every indexed project. With it, Docmancer includes matching project and relevant global memory while excluding unrelated repositories.
If you suspect an older decision explains the current conflict, include historical evidence explicitly:
docmancer ask \
"Why did the deployment process change?" \
--project "$PWD" \
--history \
--no-answer
Superseded and expired evidence stays out of ordinary recall, but --history makes it available for an audit. That lets you reconstruct a change without allowing the old rule to compete with the current answer during everyday use.
Check what changed in durable memory
Curated memory is stored as ordinary local Markdown with stable identities and an append-only mutation journal. Use the timeline to inspect recent creates, edits, moves, and recoverable deletion operations:
docmancer timeline --project "$PWD" --limit 25
Narrow the journal when you are investigating one type of change:
docmancer timeline --project "$PWD" --operation edit --limit 25
This is different from checking Git history. Agent memory can live across global and project-scoped stores, and some of it is intentionally outside the repository. The timeline records memory operations at the layer where they happened, while source attribution connects each current statement back to its supporting evidence.
Preview Context before creating a revision
The raw corpus is not automatically the same thing as delivered Context. Context is the bounded, readable artifact prepared for people and connected agents.
Preview a refresh first:
docmancer context refresh --project "$PWD" --dry-run
The preview does not call a provider or write a revision. It shows the source grouping and expected changes so you can detect an unexpectedly broad project scope or a noisy source before anything is activated.
Build the deterministic local version when the preview is correct:
docmancer context refresh --project "$PWD" --provider none
docmancer context status --project "$PWD"
docmancer context show --project "$PWD"
The local path works without an API key. Provider-assisted distillation is optional and explicit, while the default none provider preserves a deterministic workflow.
Compare revisions instead of trusting the newest file
Context revisions make changes reviewable. Once you have the revision IDs from Context status or the local app, compare them directly:
docmancer context diff <older-revision> <newer-revision> --project "$PWD"
The diff should answer the practical audit question: what will an agent learn now that it did not receive before? A large deletion may reveal that a source disappeared. A deployment rule changing from Heroku to Railway may be correct, but it should be supported by current evidence rather than silently replacing history.
If a revision is wrong, rollback is deliberate and requires confirmation:
docmancer context rollback <revision-id> --project "$PWD"
Rollback does not erase the revision chain. It restores an earlier state while preserving the history needed to explain the correction.
Verify which agents received the result
A correct Context revision is not useful if the wrong agent projection is active. Inspect delivery after a refresh:
docmancer agent refresh --agent claude-code --agent codex --project "$PWD"
docmancer delivery --project "$PWD"
Delivery reports the integration mode and latest observed bundle receipt per agent. This prevents a common operational mistake where a skill file exists, so the setup is described as connected even though the current Context was never projected or recently used.
Read-only recall hooks can be installed independently:
docmancer agent install claude-code --hooks
docmancer agent install codex --hooks
Capture remains a separate opt-in. Auditing recall does not require authorizing an agent to write new memory automatically.
Use the local workbench for a human review
The same audit is available in a browser:
docmancer web
Home provides grounded Ask with expandable provenance. Context shows the current artifact, preview and confirmation flow, revision history, and delivery state. Library exposes readable source files and indexed documentation without forcing you to browse raw internal identifiers.
The app runs on 127.0.0.1 and uses the same local store as the CLI and connected agents. It is useful when the audit requires judgment across several sources rather than one command output.
A five-command memory preflight
Before a large migration, production deployment, or security-sensitive change, run:
docmancer status --project "$PWD" --check
docmancer ask "What constraints apply to this change?" --project "$PWD" --no-answer --debug
docmancer timeline --project "$PWD" --limit 25
docmancer context refresh --project "$PWD" --dry-run
docmancer delivery --project "$PWD"
This preflight does not guarantee that every recorded decision is correct. It does make the memory system observable enough to catch missing sources, unrelated project evidence, stale history, unexpected Context changes, and incomplete delivery before those failures become code changes.
Continue with the memory management guide for stable addresses, edits, and recoverable deletion. The CLI reference covers the complete Ask, Context, agent, documentation, and Cloud command surface.