True Memory Fragments v0.1.0rc3 — source-aware stale-context protection for AI coding agents

[kyle641320]

TMF is a source-aware stale-context guard for AI coding agents.

When a coding agent remembers a call chain from an earlier session, source changes can make that memory unsafe. TMF checks the source-backed claim and blocks reuse when it is stale.

What we have validated

Through deterministic source-analysis tests, Python and Java validation, and scoped agent experiments, we have validated:

• Source-bound freshness and stale-claim detection;
• Hard stale gates that stop unsafe graph expansion;
• Explicit source fallback and localized reread guidance;
• Calls, reads, writes, inheritance, and API relationships in the covered scenarios;
• Reproducible stale-context prevention behavior across the covered Python and Java paths.

If the source binding is still current, the claim may be reused. If the source has changed, TMF stops and requires a fresh read.

In this Guava M10 experiment, TMF_STALE_GATED matched SOURCE_ONLY on evaluated semantic-boundary correctness: semantically evaluable runs passed 34/34 and 20/20 respectively, with no obsolete inline-loop placements in either arm. Raw failures were attributed to edit/finalization protocol issues rather than confirmed semantic-boundary failures. This is an observed result in this experiment, not a statistical equivalence claim or a 50/50 task-success claim.

30-second demo

Run this from a clean checkout:

git clone https://github.com/kyle641320/true-memory-fragments.git
cd true-memory-fragments
python -m pip install --pre true-memory-fragments==0.1.0rc3
python scripts/demo_stale_gate.py

Expected output:

STALE CLAIM BLOCKED: PASS
SOURCE FALLBACK PROVIDED: PASS
REREAD REQUIRED: PASS

The demo is run from the repository root; installing the PyPI package alone does not download repository demo scripts.

Scoped case study

In a 50-run Guava M10 pre-read experiment:

• TMF_STALE_GATED: 42/50 raw passes;
• SOURCE_ONLY: 40/50 raw passes;
• Both arms compiled successfully in 50/50 runs;
• PREREAD_STALE_SOURCE: 2/50 raw passes;
• STALE_DOC_CONTROL: 0/50 raw passes.

Raw passes, task-result passes, compilation, and evaluated semantic-boundary correctness are distinct measures. Task-result passes (task_result_pass, also matching post_test_ok) were 42/50 for TMF_STALE_GATED and 41/50 for SOURCE_ONLY; one SOURCE_ONLY run achieved the task result but failed raw scoring because finalization was missing. Runs without an evaluable semantic result are not counted as semantic successes, and successful compilation does not imply task success.

The two arms matched on evaluated semantic-boundary correctness (34/34 and 20/20 respectively), not on every outcome measure. Neither arm had obsolete inline-loop placements. The stale-context control arms frequently placed edits at the obsolete inline queue-drain loop (43/50 and 45/50), while the current source required the dispatchPreparedSubscriber boundary.

This observed result is limited to this experiment; it is not a statistical equivalence claim or a 50/50 task-success claim. It is not a claim of general productivity, speed, token savings, or bug reduction. The experiment uses one Guava M10 scenario, synthetic agent interactions, and protocol-sensitive scoring.

Raw results and independent audit:

• Case study: https://github.com/kyle641320/true-memory-fragments/blob/master/docs/case-studies/guava-m10-stale-gating.md
• Evidence status: https://github.com/kyle641320/true-memory-fragments/blob/master/docs/AGENT_RUNTIME_VALUE_STATUS.md

Feedback wanted

• Could you install it without reading the source?
• Is the stale-gate result understandable?
• Does it fit any real coding-agent workflow?
• Did you encounter a false positive, false negative, or unhelpful reread boundary?

Project: https://github.com/kyle641320/true-memory-fragments
PyPI: https://pypi.org/project/true-memory-fragments/

This is an independent open-source project. Feedback, criticism, and reproduction reports are welcome.

[kyle641320]

rc4 preview: source freshness, with a short Guava walkthrough

TMF: when an agent remembers code that has changed

TMF helps coding agents detect outdated source understanding and retain traceable relationships across code, so a local edit can be considered with its surrounding contracts.

A 90-second Guava evidence walkthrough

This is a narrated replay of a completed controlled experiment, not a live recording or a new run.

1. Old read. The same agent read Guava's combineOrdered and combineUnordered, which used asBytes().
2. Real upstream change. After the read, a controller integrated the upstream optimization to getBytesInternal(), keeping the old index.
3. Stale, then re-read. On resumption, both old method bindings returned fresh=false / java_hash mismatch. Tool records show the agent then read the current methods, HashCode ownership contracts and existing tests before writing regression coverage.
4. Continue development. The new regression test checked input immutability, output storage independence, result vectors and exceptions. Both executions printed:

PASS CombineByteArrayRegression: 60 checks

No production code was edited by the agent in this task. The result is 60 assertions in one regression suite, not 60 independent experiments. The controller required the TMF query protocol; this was a direct-API exercise, not a test of a native client hook or an atomic write barrier. The stale slice also included extra reading. It demonstrates a working detection → re-read → development chain, not universal dependency coverage or a no-TMF causal comparison.

Upstream source transition: old commit → new commit.

Try the published preview

Current package: 0.1.0rc4; official MCP Registry version: 0.1.0-rc4.

uvx --from 'true-memory-fragments[java]==0.1.0rc4' tmf mcp --repo /absolute/path/to/task-worktree

This starts an MCP stdio server, not an interactive chat UI. Configure it in your MCP client using the installation and first-stale walkthrough.

For a first trial, use a disposable worktree, follow the guide, and report whether setup worked and whether the stale result pointed to useful source. Please include client/version, language, expected vs actual behavior, and sanitized tool output in Q&A. No private code or credentials are needed.

We are looking for 3–5 early trial users. That is a recruitment goal, not an existing adoption count. TMF's measured development-token use in the scoped tests was broadly similar or slightly higher than source-only work; indexing is a separate cost. Its focus here is source validity and code-chain understanding.